[svn:parrot] r48110 - trunk/ext/nqp-rx/src/stage0

pmichaud at svn.parrot.org pmichaud at svn.parrot.org
Mon Jul 19 09:38:34 UTC 2010


Author: pmichaud
Date: Mon Jul 19 09:38:32 2010
New Revision: 48110
URL: https://trac.parrot.org/parrot/changeset/48110

Log:
[nqp-rx]:  Update bootstrap with regex backtracking fixes.

Modified:
   trunk/ext/nqp-rx/src/stage0/HLL-s0.pir
   trunk/ext/nqp-rx/src/stage0/NQP-s0.pir
   trunk/ext/nqp-rx/src/stage0/P6Regex-s0.pir
   trunk/ext/nqp-rx/src/stage0/Regex-s0.pir

Modified: trunk/ext/nqp-rx/src/stage0/HLL-s0.pir
==============================================================================
--- trunk/ext/nqp-rx/src/stage0/HLL-s0.pir	Mon Jul 19 07:59:55 2010	(r48109)
+++ trunk/ext/nqp-rx/src/stage0/HLL-s0.pir	Mon Jul 19 09:38:32 2010	(r48110)
@@ -902,7 +902,7 @@
 ### .include 'gen/hllgrammar-grammar.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500527.62277")
+.sub "_block11"  :anon :subid("10_1279529214.68208")
 .annotate 'line', 0
     get_hll_global $P14, ["HLL";"Grammar"], "_block13" 
     capture_lex $P14
@@ -916,103 +916,103 @@
 .annotate 'line', 5
     get_hll_global $P14, ["HLL";"Grammar"], "_block13" 
     capture_lex $P14
-    $P348 = $P14()
+    $P332 = $P14()
 .annotate 'line', 1
-    .return ($P348)
-    .const 'Sub' $P350 = "106_1278500527.62277" 
-    .return ($P350)
+    .return ($P332)
+    .const 'Sub' $P334 = "106_1279529214.68208" 
+    .return ($P334)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post107") :outer("10_1278500527.62277")
+.sub "" :load :init :subid("post107") :outer("10_1279529214.68208")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500527.62277" 
+    .const 'Sub' $P12 = "10_1279529214.68208" 
     .local pmc block
     set block, $P12
-    $P353 = get_root_global ["parrot"], "P6metaclass"
-    $P353."new_class"("HLL::Grammar", "Regex::Cursor" :named("parent"))
+    $P337 = get_root_global ["parrot"], "P6metaclass"
+    $P337."new_class"("HLL::Grammar", "Regex::Cursor" :named("parent"))
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "_block13"  :subid("11_1278500527.62277") :outer("10_1278500527.62277")
+.sub "_block13"  :subid("11_1279529214.68208") :outer("10_1279529214.68208")
 .annotate 'line', 5
-    .const 'Sub' $P334 = "103_1278500527.62277" 
-    capture_lex $P334
-    .const 'Sub' $P327 = "101_1278500527.62277" 
-    capture_lex $P327
-    .const 'Sub' $P314 = "98_1278500527.62277" 
-    capture_lex $P314
-    .const 'Sub' $P282 = "93_1278500527.62277" 
-    capture_lex $P282
-    .const 'Sub' $P276 = "91_1278500527.62277" 
-    capture_lex $P276
-    .const 'Sub' $P271 = "89_1278500527.62277" 
-    capture_lex $P271
-    .const 'Sub' $P265 = "87_1278500527.62277" 
-    capture_lex $P265
-    .const 'Sub' $P259 = "85_1278500527.62277" 
-    capture_lex $P259
-    .const 'Sub' $P254 = "83_1278500527.62277" 
-    capture_lex $P254
-    .const 'Sub' $P249 = "81_1278500527.62277" 
-    capture_lex $P249
-    .const 'Sub' $P244 = "79_1278500527.62277" 
-    capture_lex $P244
-    .const 'Sub' $P239 = "77_1278500527.62277" 
-    capture_lex $P239
-    .const 'Sub' $P234 = "75_1278500527.62277" 
-    capture_lex $P234
-    .const 'Sub' $P229 = "73_1278500527.62277" 
-    capture_lex $P229
-    .const 'Sub' $P224 = "71_1278500527.62277" 
-    capture_lex $P224
-    .const 'Sub' $P219 = "69_1278500527.62277" 
-    capture_lex $P219
-    .const 'Sub' $P208 = "65_1278500527.62277" 
-    capture_lex $P208
-    .const 'Sub' $P195 = "63_1278500527.62277" 
+    .const 'Sub' $P319 = "103_1279529214.68208" 
+    capture_lex $P319
+    .const 'Sub' $P313 = "101_1279529214.68208" 
+    capture_lex $P313
+    .const 'Sub' $P300 = "98_1279529214.68208" 
+    capture_lex $P300
+    .const 'Sub' $P268 = "93_1279529214.68208" 
+    capture_lex $P268
+    .const 'Sub' $P262 = "91_1279529214.68208" 
+    capture_lex $P262
+    .const 'Sub' $P257 = "89_1279529214.68208" 
+    capture_lex $P257
+    .const 'Sub' $P251 = "87_1279529214.68208" 
+    capture_lex $P251
+    .const 'Sub' $P245 = "85_1279529214.68208" 
+    capture_lex $P245
+    .const 'Sub' $P240 = "83_1279529214.68208" 
+    capture_lex $P240
+    .const 'Sub' $P235 = "81_1279529214.68208" 
+    capture_lex $P235
+    .const 'Sub' $P230 = "79_1279529214.68208" 
+    capture_lex $P230
+    .const 'Sub' $P225 = "77_1279529214.68208" 
+    capture_lex $P225
+    .const 'Sub' $P220 = "75_1279529214.68208" 
+    capture_lex $P220
+    .const 'Sub' $P215 = "73_1279529214.68208" 
+    capture_lex $P215
+    .const 'Sub' $P210 = "71_1279529214.68208" 
+    capture_lex $P210
+    .const 'Sub' $P205 = "69_1279529214.68208" 
+    capture_lex $P205
+    .const 'Sub' $P195 = "65_1279529214.68208" 
     capture_lex $P195
-    .const 'Sub' $P183 = "61_1278500527.62277" 
-    capture_lex $P183
-    .const 'Sub' $P176 = "59_1278500527.62277" 
-    capture_lex $P176
-    .const 'Sub' $P167 = "57_1278500527.62277" 
-    capture_lex $P167
-    .const 'Sub' $P160 = "55_1278500527.62277" 
-    capture_lex $P160
-    .const 'Sub' $P151 = "53_1278500527.62277" 
+    .const 'Sub' $P182 = "63_1279529214.68208" 
+    capture_lex $P182
+    .const 'Sub' $P170 = "61_1279529214.68208" 
+    capture_lex $P170
+    .const 'Sub' $P164 = "59_1279529214.68208" 
+    capture_lex $P164
+    .const 'Sub' $P157 = "57_1279529214.68208" 
+    capture_lex $P157
+    .const 'Sub' $P151 = "55_1279529214.68208" 
     capture_lex $P151
-    .const 'Sub' $P144 = "51_1278500527.62277" 
+    .const 'Sub' $P144 = "53_1279529214.68208" 
     capture_lex $P144
-    .const 'Sub' $P135 = "49_1278500527.62277" 
-    capture_lex $P135
-    .const 'Sub' $P128 = "47_1278500527.62277" 
-    capture_lex $P128
-    .const 'Sub' $P121 = "45_1278500527.62277" 
-    capture_lex $P121
-    .const 'Sub' $P111 = "43_1278500527.62277" 
-    capture_lex $P111
-    .const 'Sub' $P103 = "41_1278500527.62277" 
-    capture_lex $P103
-    .const 'Sub' $P93 = "40_1278500527.62277" 
-    capture_lex $P93
-    .const 'Sub' $P87 = "38_1278500527.62277" 
-    capture_lex $P87
-    .const 'Sub' $P82 = "36_1278500527.62277" 
-    capture_lex $P82
-    .const 'Sub' $P74 = "34_1278500527.62277" 
-    capture_lex $P74
-    .const 'Sub' $P68 = "32_1278500527.62277" 
-    capture_lex $P68
-    .const 'Sub' $P62 = "30_1278500527.62277" 
-    capture_lex $P62
-    .const 'Sub' $P56 = "28_1278500527.62277" 
-    capture_lex $P56
-    .const 'Sub' $P23 = "14_1278500527.62277" 
-    capture_lex $P23
-    .const 'Sub' $P15 = "12_1278500527.62277" 
+    .const 'Sub' $P138 = "51_1279529214.68208" 
+    capture_lex $P138
+    .const 'Sub' $P131 = "49_1279529214.68208" 
+    capture_lex $P131
+    .const 'Sub' $P125 = "47_1279529214.68208" 
+    capture_lex $P125
+    .const 'Sub' $P119 = "45_1279529214.68208" 
+    capture_lex $P119
+    .const 'Sub' $P110 = "43_1279529214.68208" 
+    capture_lex $P110
+    .const 'Sub' $P102 = "41_1279529214.68208" 
+    capture_lex $P102
+    .const 'Sub' $P92 = "40_1279529214.68208" 
+    capture_lex $P92
+    .const 'Sub' $P86 = "38_1279529214.68208" 
+    capture_lex $P86
+    .const 'Sub' $P81 = "36_1279529214.68208" 
+    capture_lex $P81
+    .const 'Sub' $P73 = "34_1279529214.68208" 
+    capture_lex $P73
+    .const 'Sub' $P67 = "32_1279529214.68208" 
+    capture_lex $P67
+    .const 'Sub' $P61 = "30_1279529214.68208" 
+    capture_lex $P61
+    .const 'Sub' $P55 = "28_1279529214.68208" 
+    capture_lex $P55
+    .const 'Sub' $P22 = "14_1279529214.68208" 
+    capture_lex $P22
+    .const 'Sub' $P15 = "12_1279529214.68208" 
     capture_lex $P15
     $P0 = find_dynamic_lex "$*CTXSAVE"
     if null $P0 goto ctxsave_done
@@ -1021,17 +1021,17 @@
     $P0."ctxsave"()
   ctxsave_done:
 .annotate 'line', 33
-    .const 'Sub' $P334 = "103_1278500527.62277" 
-    capture_lex $P334
+    .const 'Sub' $P319 = "103_1279529214.68208" 
+    capture_lex $P319
 .annotate 'line', 5
-    .return ($P334)
-    .const 'Sub' $P345 = "105_1278500527.62277" 
-    .return ($P345)
+    .return ($P319)
+    .const 'Sub' $P329 = "105_1279529214.68208" 
+    .return ($P329)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "ws"  :subid("12_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "ws"  :subid("12_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
     .local string rx16_tgt
     .local int rx16_pos
@@ -1039,8 +1039,7 @@
     .local int rx16_eos
     .local int rx16_rep
     .local pmc rx16_cur
-    (rx16_cur, rx16_pos, rx16_tgt) = self."!cursor_start"()
-    rx16_cur."!cursor_debug"("START ", "ws")
+    (rx16_cur, rx16_pos, rx16_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx16_cur
     .local pmc match
     .lex "$/", match
@@ -1051,6 +1050,8 @@
     sub rx16_off, rx16_pos, 1
     substr rx16_tgt, rx16_tgt, rx16_off
   rx16_start:
+    eq $I10, 1, rx16_restart
+    rx16_cur."!cursor_debug"("START ", "ws")
     $I10 = self.'from'()
     ne $I10, -1, rxscan19_done
     goto rxscan19_scan
@@ -1068,8 +1069,8 @@
     $P10 = rx16_cur."ww"()
     if $P10, rx16_fail
   # rx rxquantr20 ** 0..*
-    set_addr $I22, rxquantr20_done
-    rx16_cur."!mark_push"(0, rx16_pos, $I22)
+    set_addr $I10, rxquantr20_done
+    rx16_cur."!mark_push"(0, rx16_pos, $I10)
   rxquantr20_loop:
   alt21_0:
     set_addr $I10, alt21_1
@@ -1094,14 +1095,18 @@
     find_cclass $I11, 4096, rx16_tgt, $I10, rx16_eos
     add rx16_pos, rx16_off, $I11
   alt21_end:
-    (rx16_rep) = rx16_cur."!mark_commit"($I22)
-    rx16_cur."!mark_push"(rx16_rep, rx16_pos, $I22)
+    set_addr $I10, rxquantr20_done
+    (rx16_rep) = rx16_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr20_done
+    rx16_cur."!mark_push"(rx16_rep, rx16_pos, $I10)
     goto rxquantr20_loop
   rxquantr20_done:
   # rx pass
     rx16_cur."!cursor_pass"(rx16_pos, "ws")
     rx16_cur."!cursor_debug"("PASS  ", "ws", " at pos=", rx16_pos)
     .return (rx16_cur)
+  rx16_restart:
+    rx16_cur."!cursor_debug"("NEXT ", "ws")
   rx16_fail:
     (rx16_rep, rx16_pos, $I10, $P10) = rx16_cur."!mark_fail"(0)
     lt rx16_pos, -1, rx16_done
@@ -1116,7 +1121,7 @@
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__ws"  :subid("13_1278500527.62277") :method
+.sub "!PREFIX__ws"  :subid("13_1279529214.68208") :method
 .annotate 'line', 5
     new $P18, "ResizablePMCArray"
     push $P18, ""
@@ -1125,1123 +1130,1292 @@
 
 
 .namespace ["HLL";"Grammar"]
-.sub "termish"  :subid("14_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "termish"  :subid("14_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx24_tgt
-    .local int rx24_pos
-    .local int rx24_off
-    .local int rx24_eos
-    .local int rx24_rep
-    .local pmc rx24_cur
-    (rx24_cur, rx24_pos, rx24_tgt) = self."!cursor_start"()
-    rx24_cur."!cursor_debug"("START ", "termish")
-    rx24_cur."!cursor_caparray"("postfixish", "prefixish")
-    .lex unicode:"$\x{a2}", rx24_cur
+    .local string rx23_tgt
+    .local int rx23_pos
+    .local int rx23_off
+    .local int rx23_eos
+    .local int rx23_rep
+    .local pmc rx23_cur
+    (rx23_cur, rx23_pos, rx23_tgt, $I10) = self."!cursor_start"()
+    rx23_cur."!cursor_caparray"("postfixish", "prefixish")
+    .lex unicode:"$\x{a2}", rx23_cur
     .local pmc match
     .lex "$/", match
-    length rx24_eos, rx24_tgt
-    gt rx24_pos, rx24_eos, rx24_done
-    set rx24_off, 0
-    lt rx24_pos, 2, rx24_start
-    sub rx24_off, rx24_pos, 1
-    substr rx24_tgt, rx24_tgt, rx24_off
-  rx24_start:
+    length rx23_eos, rx23_tgt
+    gt rx23_pos, rx23_eos, rx23_done
+    set rx23_off, 0
+    lt rx23_pos, 2, rx23_start
+    sub rx23_off, rx23_pos, 1
+    substr rx23_tgt, rx23_tgt, rx23_off
+  rx23_start:
+    eq $I10, 1, rx23_restart
+    rx23_cur."!cursor_debug"("START ", "termish")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan27_done
-    goto rxscan27_scan
-  rxscan27_loop:
-    ($P10) = rx24_cur."from"()
+    ne $I10, -1, rxscan26_done
+    goto rxscan26_scan
+  rxscan26_loop:
+    ($P10) = rx23_cur."from"()
     inc $P10
-    set rx24_pos, $P10
-    ge rx24_pos, rx24_eos, rxscan27_done
-  rxscan27_scan:
-    set_addr $I10, rxscan27_loop
-    rx24_cur."!mark_push"(0, rx24_pos, $I10)
-  rxscan27_done:
+    set rx23_pos, $P10
+    ge rx23_pos, rx23_eos, rxscan26_done
+  rxscan26_scan:
+    set_addr $I10, rxscan26_loop
+    rx23_cur."!mark_push"(0, rx23_pos, $I10)
+  rxscan26_done:
 .annotate 'line', 8
-  # rx rxquantr28 ** 0..*
-    set_addr $I29, rxquantr28_done
-    rx24_cur."!mark_push"(0, rx24_pos, $I29)
-  rxquantr28_loop:
+  # rx rxquantr27 ** 0..*
+    set_addr $I10, rxquantr27_done
+    rx23_cur."!mark_push"(0, rx23_pos, $I10)
+  rxquantr27_loop:
   # rx subrule "prefixish" subtype=capture negate=
-    rx24_cur."!cursor_pos"(rx24_pos)
-    $P10 = rx24_cur."prefixish"()
-    unless $P10, rx24_fail
-    rx24_cur."!mark_push"(0, -1, 0, $P10)
+    rx23_cur."!cursor_pos"(rx23_pos)
+    $P10 = rx23_cur."prefixish"()
+    unless $P10, rx23_fail
+    goto rxsubrule28_pass
+  rxsubrule28_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx23_fail
+  rxsubrule28_pass:
+    set_addr $I10, rxsubrule28_back
+    rx23_cur."!mark_push"(0, rx23_pos, $I10, $P10)
     $P10."!cursor_names"("prefixish")
-    rx24_pos = $P10."pos"()
-    (rx24_rep) = rx24_cur."!mark_commit"($I29)
-    rx24_cur."!mark_push"(rx24_rep, rx24_pos, $I29)
-    goto rxquantr28_loop
-  rxquantr28_done:
+    rx23_pos = $P10."pos"()
+    set_addr $I10, rxquantr27_done
+    (rx23_rep) = rx23_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr27_done
+    rx23_cur."!mark_push"(rx23_rep, rx23_pos, $I10)
+    goto rxquantr27_loop
+  rxquantr27_done:
 .annotate 'line', 9
   # rx subrule "term" subtype=capture negate=
-    rx24_cur."!cursor_pos"(rx24_pos)
-    $P10 = rx24_cur."term"()
-    unless $P10, rx24_fail
-    rx24_cur."!mark_push"(0, -1, 0, $P10)
+    rx23_cur."!cursor_pos"(rx23_pos)
+    $P10 = rx23_cur."term"()
+    unless $P10, rx23_fail
+    rx23_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("term")
-    rx24_pos = $P10."pos"()
+    rx23_pos = $P10."pos"()
 .annotate 'line', 10
-  # rx rxquantr30 ** 0..*
-    set_addr $I31, rxquantr30_done
-    rx24_cur."!mark_push"(0, rx24_pos, $I31)
-  rxquantr30_loop:
+  # rx rxquantr29 ** 0..*
+    set_addr $I10, rxquantr29_done
+    rx23_cur."!mark_push"(0, rx23_pos, $I10)
+  rxquantr29_loop:
   # rx subrule "postfixish" subtype=capture negate=
-    rx24_cur."!cursor_pos"(rx24_pos)
-    $P10 = rx24_cur."postfixish"()
-    unless $P10, rx24_fail
-    rx24_cur."!mark_push"(0, -1, 0, $P10)
+    rx23_cur."!cursor_pos"(rx23_pos)
+    $P10 = rx23_cur."postfixish"()
+    unless $P10, rx23_fail
+    goto rxsubrule30_pass
+  rxsubrule30_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx23_fail
+  rxsubrule30_pass:
+    set_addr $I10, rxsubrule30_back
+    rx23_cur."!mark_push"(0, rx23_pos, $I10, $P10)
     $P10."!cursor_names"("postfixish")
-    rx24_pos = $P10."pos"()
-    (rx24_rep) = rx24_cur."!mark_commit"($I31)
-    rx24_cur."!mark_push"(rx24_rep, rx24_pos, $I31)
-    goto rxquantr30_loop
-  rxquantr30_done:
+    rx23_pos = $P10."pos"()
+    set_addr $I10, rxquantr29_done
+    (rx23_rep) = rx23_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr29_done
+    rx23_cur."!mark_push"(rx23_rep, rx23_pos, $I10)
+    goto rxquantr29_loop
+  rxquantr29_done:
 .annotate 'line', 7
   # rx pass
-    rx24_cur."!cursor_pass"(rx24_pos, "termish")
-    rx24_cur."!cursor_debug"("PASS  ", "termish", " at pos=", rx24_pos)
-    .return (rx24_cur)
-  rx24_fail:
+    rx23_cur."!cursor_pass"(rx23_pos, "termish")
+    rx23_cur."!cursor_debug"("PASS  ", "termish", " at pos=", rx23_pos)
+    .return (rx23_cur)
+  rx23_restart:
 .annotate 'line', 5
-    (rx24_rep, rx24_pos, $I10, $P10) = rx24_cur."!mark_fail"(0)
-    lt rx24_pos, -1, rx24_done
-    eq rx24_pos, -1, rx24_fail
+    rx23_cur."!cursor_debug"("NEXT ", "termish")
+  rx23_fail:
+    (rx23_rep, rx23_pos, $I10, $P10) = rx23_cur."!mark_fail"(0)
+    lt rx23_pos, -1, rx23_done
+    eq rx23_pos, -1, rx23_fail
     jump $I10
-  rx24_done:
-    rx24_cur."!cursor_fail"()
-    rx24_cur."!cursor_debug"("FAIL  ", "termish")
-    .return (rx24_cur)
+  rx23_done:
+    rx23_cur."!cursor_fail"()
+    rx23_cur."!cursor_debug"("FAIL  ", "termish")
+    .return (rx23_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__termish"  :subid("15_1278500527.62277") :method
+.sub "!PREFIX__termish"  :subid("15_1279529214.68208") :method
 .annotate 'line', 5
-    new $P26, "ResizablePMCArray"
-    push $P26, ""
-    .return ($P26)
+    new $P25, "ResizablePMCArray"
+    push $P25, ""
+    .return ($P25)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "term"  :subid("16_1278500527.62277") :method
+.sub "term"  :subid("16_1279529214.68208") :method
 .annotate 'line', 13
-    $P33 = self."!protoregex"("term")
-    .return ($P33)
+    $P32 = self."!protoregex"("term")
+    .return ($P32)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__term"  :subid("17_1278500527.62277") :method
+.sub "!PREFIX__term"  :subid("17_1279529214.68208") :method
 .annotate 'line', 13
-    $P35 = self."!PREFIX__!protoregex"("term")
-    .return ($P35)
+    $P34 = self."!PREFIX__!protoregex"("term")
+    .return ($P34)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "infix"  :subid("18_1278500527.62277") :method
+.sub "infix"  :subid("18_1279529214.68208") :method
 .annotate 'line', 14
-    $P37 = self."!protoregex"("infix")
-    .return ($P37)
+    $P36 = self."!protoregex"("infix")
+    .return ($P36)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__infix"  :subid("19_1278500527.62277") :method
+.sub "!PREFIX__infix"  :subid("19_1279529214.68208") :method
 .annotate 'line', 14
-    $P39 = self."!PREFIX__!protoregex"("infix")
-    .return ($P39)
+    $P38 = self."!PREFIX__!protoregex"("infix")
+    .return ($P38)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "prefix"  :subid("20_1278500527.62277") :method
+.sub "prefix"  :subid("20_1279529214.68208") :method
 .annotate 'line', 15
-    $P41 = self."!protoregex"("prefix")
-    .return ($P41)
+    $P40 = self."!protoregex"("prefix")
+    .return ($P40)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__prefix"  :subid("21_1278500527.62277") :method
+.sub "!PREFIX__prefix"  :subid("21_1279529214.68208") :method
 .annotate 'line', 15
-    $P43 = self."!PREFIX__!protoregex"("prefix")
-    .return ($P43)
+    $P42 = self."!PREFIX__!protoregex"("prefix")
+    .return ($P42)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "postfix"  :subid("22_1278500527.62277") :method
+.sub "postfix"  :subid("22_1279529214.68208") :method
 .annotate 'line', 16
-    $P45 = self."!protoregex"("postfix")
-    .return ($P45)
+    $P44 = self."!protoregex"("postfix")
+    .return ($P44)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__postfix"  :subid("23_1278500527.62277") :method
+.sub "!PREFIX__postfix"  :subid("23_1279529214.68208") :method
 .annotate 'line', 16
-    $P47 = self."!PREFIX__!protoregex"("postfix")
-    .return ($P47)
+    $P46 = self."!PREFIX__!protoregex"("postfix")
+    .return ($P46)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "circumfix"  :subid("24_1278500527.62277") :method
+.sub "circumfix"  :subid("24_1279529214.68208") :method
 .annotate 'line', 17
-    $P49 = self."!protoregex"("circumfix")
-    .return ($P49)
+    $P48 = self."!protoregex"("circumfix")
+    .return ($P48)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__circumfix"  :subid("25_1278500527.62277") :method
+.sub "!PREFIX__circumfix"  :subid("25_1279529214.68208") :method
 .annotate 'line', 17
-    $P51 = self."!PREFIX__!protoregex"("circumfix")
-    .return ($P51)
+    $P50 = self."!PREFIX__!protoregex"("circumfix")
+    .return ($P50)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "postcircumfix"  :subid("26_1278500527.62277") :method
+.sub "postcircumfix"  :subid("26_1279529214.68208") :method
 .annotate 'line', 18
-    $P53 = self."!protoregex"("postcircumfix")
-    .return ($P53)
+    $P52 = self."!protoregex"("postcircumfix")
+    .return ($P52)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__postcircumfix"  :subid("27_1278500527.62277") :method
+.sub "!PREFIX__postcircumfix"  :subid("27_1279529214.68208") :method
 .annotate 'line', 18
-    $P55 = self."!PREFIX__!protoregex"("postcircumfix")
-    .return ($P55)
+    $P54 = self."!PREFIX__!protoregex"("postcircumfix")
+    .return ($P54)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "term:sym<circumfix>"  :subid("28_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "term:sym<circumfix>"  :subid("28_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx57_tgt
-    .local int rx57_pos
-    .local int rx57_off
-    .local int rx57_eos
-    .local int rx57_rep
-    .local pmc rx57_cur
-    (rx57_cur, rx57_pos, rx57_tgt) = self."!cursor_start"()
-    rx57_cur."!cursor_debug"("START ", "term:sym<circumfix>")
-    .lex unicode:"$\x{a2}", rx57_cur
+    .local string rx56_tgt
+    .local int rx56_pos
+    .local int rx56_off
+    .local int rx56_eos
+    .local int rx56_rep
+    .local pmc rx56_cur
+    (rx56_cur, rx56_pos, rx56_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx56_cur
     .local pmc match
     .lex "$/", match
-    length rx57_eos, rx57_tgt
-    gt rx57_pos, rx57_eos, rx57_done
-    set rx57_off, 0
-    lt rx57_pos, 2, rx57_start
-    sub rx57_off, rx57_pos, 1
-    substr rx57_tgt, rx57_tgt, rx57_off
-  rx57_start:
+    length rx56_eos, rx56_tgt
+    gt rx56_pos, rx56_eos, rx56_done
+    set rx56_off, 0
+    lt rx56_pos, 2, rx56_start
+    sub rx56_off, rx56_pos, 1
+    substr rx56_tgt, rx56_tgt, rx56_off
+  rx56_start:
+    eq $I10, 1, rx56_restart
+    rx56_cur."!cursor_debug"("START ", "term:sym<circumfix>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan61_done
-    goto rxscan61_scan
-  rxscan61_loop:
-    ($P10) = rx57_cur."from"()
+    ne $I10, -1, rxscan60_done
+    goto rxscan60_scan
+  rxscan60_loop:
+    ($P10) = rx56_cur."from"()
     inc $P10
-    set rx57_pos, $P10
-    ge rx57_pos, rx57_eos, rxscan61_done
-  rxscan61_scan:
-    set_addr $I10, rxscan61_loop
-    rx57_cur."!mark_push"(0, rx57_pos, $I10)
-  rxscan61_done:
+    set rx56_pos, $P10
+    ge rx56_pos, rx56_eos, rxscan60_done
+  rxscan60_scan:
+    set_addr $I10, rxscan60_loop
+    rx56_cur."!mark_push"(0, rx56_pos, $I10)
+  rxscan60_done:
 .annotate 'line', 20
   # rx subrule "circumfix" subtype=capture negate=
-    rx57_cur."!cursor_pos"(rx57_pos)
-    $P10 = rx57_cur."circumfix"()
-    unless $P10, rx57_fail
-    rx57_cur."!mark_push"(0, -1, 0, $P10)
+    rx56_cur."!cursor_pos"(rx56_pos)
+    $P10 = rx56_cur."circumfix"()
+    unless $P10, rx56_fail
+    rx56_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("circumfix")
-    rx57_pos = $P10."pos"()
+    rx56_pos = $P10."pos"()
   # rx pass
-    rx57_cur."!cursor_pass"(rx57_pos, "term:sym<circumfix>")
-    rx57_cur."!cursor_debug"("PASS  ", "term:sym<circumfix>", " at pos=", rx57_pos)
-    .return (rx57_cur)
-  rx57_fail:
+    rx56_cur."!cursor_pass"(rx56_pos, "term:sym<circumfix>")
+    rx56_cur."!cursor_debug"("PASS  ", "term:sym<circumfix>", " at pos=", rx56_pos)
+    .return (rx56_cur)
+  rx56_restart:
 .annotate 'line', 5
-    (rx57_rep, rx57_pos, $I10, $P10) = rx57_cur."!mark_fail"(0)
-    lt rx57_pos, -1, rx57_done
-    eq rx57_pos, -1, rx57_fail
+    rx56_cur."!cursor_debug"("NEXT ", "term:sym<circumfix>")
+  rx56_fail:
+    (rx56_rep, rx56_pos, $I10, $P10) = rx56_cur."!mark_fail"(0)
+    lt rx56_pos, -1, rx56_done
+    eq rx56_pos, -1, rx56_fail
     jump $I10
-  rx57_done:
-    rx57_cur."!cursor_fail"()
-    rx57_cur."!cursor_debug"("FAIL  ", "term:sym<circumfix>")
-    .return (rx57_cur)
+  rx56_done:
+    rx56_cur."!cursor_fail"()
+    rx56_cur."!cursor_debug"("FAIL  ", "term:sym<circumfix>")
+    .return (rx56_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__term:sym<circumfix>"  :subid("29_1278500527.62277") :method
+.sub "!PREFIX__term:sym<circumfix>"  :subid("29_1279529214.68208") :method
 .annotate 'line', 5
-    $P59 = self."!PREFIX__!subrule"("circumfix", "")
-    new $P60, "ResizablePMCArray"
-    push $P60, $P59
-    .return ($P60)
+    $P58 = self."!PREFIX__!subrule"("circumfix", "")
+    new $P59, "ResizablePMCArray"
+    push $P59, $P58
+    .return ($P59)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "infixish"  :subid("30_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "infixish"  :subid("30_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx63_tgt
-    .local int rx63_pos
-    .local int rx63_off
-    .local int rx63_eos
-    .local int rx63_rep
-    .local pmc rx63_cur
-    (rx63_cur, rx63_pos, rx63_tgt) = self."!cursor_start"()
-    rx63_cur."!cursor_debug"("START ", "infixish")
-    .lex unicode:"$\x{a2}", rx63_cur
+    .local string rx62_tgt
+    .local int rx62_pos
+    .local int rx62_off
+    .local int rx62_eos
+    .local int rx62_rep
+    .local pmc rx62_cur
+    (rx62_cur, rx62_pos, rx62_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx62_cur
     .local pmc match
     .lex "$/", match
-    length rx63_eos, rx63_tgt
-    gt rx63_pos, rx63_eos, rx63_done
-    set rx63_off, 0
-    lt rx63_pos, 2, rx63_start
-    sub rx63_off, rx63_pos, 1
-    substr rx63_tgt, rx63_tgt, rx63_off
-  rx63_start:
+    length rx62_eos, rx62_tgt
+    gt rx62_pos, rx62_eos, rx62_done
+    set rx62_off, 0
+    lt rx62_pos, 2, rx62_start
+    sub rx62_off, rx62_pos, 1
+    substr rx62_tgt, rx62_tgt, rx62_off
+  rx62_start:
+    eq $I10, 1, rx62_restart
+    rx62_cur."!cursor_debug"("START ", "infixish")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan67_done
-    goto rxscan67_scan
-  rxscan67_loop:
-    ($P10) = rx63_cur."from"()
+    ne $I10, -1, rxscan66_done
+    goto rxscan66_scan
+  rxscan66_loop:
+    ($P10) = rx62_cur."from"()
     inc $P10
-    set rx63_pos, $P10
-    ge rx63_pos, rx63_eos, rxscan67_done
-  rxscan67_scan:
-    set_addr $I10, rxscan67_loop
-    rx63_cur."!mark_push"(0, rx63_pos, $I10)
-  rxscan67_done:
+    set rx62_pos, $P10
+    ge rx62_pos, rx62_eos, rxscan66_done
+  rxscan66_scan:
+    set_addr $I10, rxscan66_loop
+    rx62_cur."!mark_push"(0, rx62_pos, $I10)
+  rxscan66_done:
 .annotate 'line', 22
   # rx subrule "infix" subtype=capture negate=
-    rx63_cur."!cursor_pos"(rx63_pos)
-    $P10 = rx63_cur."infix"()
-    unless $P10, rx63_fail
-    rx63_cur."!mark_push"(0, -1, 0, $P10)
+    rx62_cur."!cursor_pos"(rx62_pos)
+    $P10 = rx62_cur."infix"()
+    unless $P10, rx62_fail
+    rx62_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("OPER=infix")
-    rx63_pos = $P10."pos"()
+    rx62_pos = $P10."pos"()
   # rx pass
-    rx63_cur."!cursor_pass"(rx63_pos, "infixish")
-    rx63_cur."!cursor_debug"("PASS  ", "infixish", " at pos=", rx63_pos)
-    .return (rx63_cur)
-  rx63_fail:
+    rx62_cur."!cursor_pass"(rx62_pos, "infixish")
+    rx62_cur."!cursor_debug"("PASS  ", "infixish", " at pos=", rx62_pos)
+    .return (rx62_cur)
+  rx62_restart:
 .annotate 'line', 5
-    (rx63_rep, rx63_pos, $I10, $P10) = rx63_cur."!mark_fail"(0)
-    lt rx63_pos, -1, rx63_done
-    eq rx63_pos, -1, rx63_fail
+    rx62_cur."!cursor_debug"("NEXT ", "infixish")
+  rx62_fail:
+    (rx62_rep, rx62_pos, $I10, $P10) = rx62_cur."!mark_fail"(0)
+    lt rx62_pos, -1, rx62_done
+    eq rx62_pos, -1, rx62_fail
     jump $I10
-  rx63_done:
-    rx63_cur."!cursor_fail"()
-    rx63_cur."!cursor_debug"("FAIL  ", "infixish")
-    .return (rx63_cur)
+  rx62_done:
+    rx62_cur."!cursor_fail"()
+    rx62_cur."!cursor_debug"("FAIL  ", "infixish")
+    .return (rx62_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__infixish"  :subid("31_1278500527.62277") :method
+.sub "!PREFIX__infixish"  :subid("31_1279529214.68208") :method
 .annotate 'line', 5
-    $P65 = self."!PREFIX__!subrule"("infix", "")
-    new $P66, "ResizablePMCArray"
-    push $P66, $P65
-    .return ($P66)
+    $P64 = self."!PREFIX__!subrule"("infix", "")
+    new $P65, "ResizablePMCArray"
+    push $P65, $P64
+    .return ($P65)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "prefixish"  :subid("32_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "prefixish"  :subid("32_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx69_tgt
-    .local int rx69_pos
-    .local int rx69_off
-    .local int rx69_eos
-    .local int rx69_rep
-    .local pmc rx69_cur
-    (rx69_cur, rx69_pos, rx69_tgt) = self."!cursor_start"()
-    rx69_cur."!cursor_debug"("START ", "prefixish")
-    .lex unicode:"$\x{a2}", rx69_cur
+    .local string rx68_tgt
+    .local int rx68_pos
+    .local int rx68_off
+    .local int rx68_eos
+    .local int rx68_rep
+    .local pmc rx68_cur
+    (rx68_cur, rx68_pos, rx68_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx68_cur
     .local pmc match
     .lex "$/", match
-    length rx69_eos, rx69_tgt
-    gt rx69_pos, rx69_eos, rx69_done
-    set rx69_off, 0
-    lt rx69_pos, 2, rx69_start
-    sub rx69_off, rx69_pos, 1
-    substr rx69_tgt, rx69_tgt, rx69_off
-  rx69_start:
+    length rx68_eos, rx68_tgt
+    gt rx68_pos, rx68_eos, rx68_done
+    set rx68_off, 0
+    lt rx68_pos, 2, rx68_start
+    sub rx68_off, rx68_pos, 1
+    substr rx68_tgt, rx68_tgt, rx68_off
+  rx68_start:
+    eq $I10, 1, rx68_restart
+    rx68_cur."!cursor_debug"("START ", "prefixish")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan73_done
-    goto rxscan73_scan
-  rxscan73_loop:
-    ($P10) = rx69_cur."from"()
+    ne $I10, -1, rxscan72_done
+    goto rxscan72_scan
+  rxscan72_loop:
+    ($P10) = rx68_cur."from"()
     inc $P10
-    set rx69_pos, $P10
-    ge rx69_pos, rx69_eos, rxscan73_done
-  rxscan73_scan:
-    set_addr $I10, rxscan73_loop
-    rx69_cur."!mark_push"(0, rx69_pos, $I10)
-  rxscan73_done:
+    set rx68_pos, $P10
+    ge rx68_pos, rx68_eos, rxscan72_done
+  rxscan72_scan:
+    set_addr $I10, rxscan72_loop
+    rx68_cur."!mark_push"(0, rx68_pos, $I10)
+  rxscan72_done:
 .annotate 'line', 23
   # rx subrule "prefix" subtype=capture negate=
-    rx69_cur."!cursor_pos"(rx69_pos)
-    $P10 = rx69_cur."prefix"()
-    unless $P10, rx69_fail
-    rx69_cur."!mark_push"(0, -1, 0, $P10)
+    rx68_cur."!cursor_pos"(rx68_pos)
+    $P10 = rx68_cur."prefix"()
+    unless $P10, rx68_fail
+    rx68_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("OPER=prefix")
-    rx69_pos = $P10."pos"()
+    rx68_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx69_cur."!cursor_pos"(rx69_pos)
-    $P10 = rx69_cur."ws"()
-    unless $P10, rx69_fail
-    rx69_pos = $P10."pos"()
+    rx68_cur."!cursor_pos"(rx68_pos)
+    $P10 = rx68_cur."ws"()
+    unless $P10, rx68_fail
+    rx68_pos = $P10."pos"()
   # rx pass
-    rx69_cur."!cursor_pass"(rx69_pos, "prefixish")
-    rx69_cur."!cursor_debug"("PASS  ", "prefixish", " at pos=", rx69_pos)
-    .return (rx69_cur)
-  rx69_fail:
+    rx68_cur."!cursor_pass"(rx68_pos, "prefixish")
+    rx68_cur."!cursor_debug"("PASS  ", "prefixish", " at pos=", rx68_pos)
+    .return (rx68_cur)
+  rx68_restart:
 .annotate 'line', 5
-    (rx69_rep, rx69_pos, $I10, $P10) = rx69_cur."!mark_fail"(0)
-    lt rx69_pos, -1, rx69_done
-    eq rx69_pos, -1, rx69_fail
+    rx68_cur."!cursor_debug"("NEXT ", "prefixish")
+  rx68_fail:
+    (rx68_rep, rx68_pos, $I10, $P10) = rx68_cur."!mark_fail"(0)
+    lt rx68_pos, -1, rx68_done
+    eq rx68_pos, -1, rx68_fail
     jump $I10
-  rx69_done:
-    rx69_cur."!cursor_fail"()
-    rx69_cur."!cursor_debug"("FAIL  ", "prefixish")
-    .return (rx69_cur)
+  rx68_done:
+    rx68_cur."!cursor_fail"()
+    rx68_cur."!cursor_debug"("FAIL  ", "prefixish")
+    .return (rx68_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__prefixish"  :subid("33_1278500527.62277") :method
+.sub "!PREFIX__prefixish"  :subid("33_1279529214.68208") :method
 .annotate 'line', 5
-    $P71 = self."!PREFIX__!subrule"("prefix", "")
-    new $P72, "ResizablePMCArray"
-    push $P72, $P71
-    .return ($P72)
+    $P70 = self."!PREFIX__!subrule"("prefix", "")
+    new $P71, "ResizablePMCArray"
+    push $P71, $P70
+    .return ($P71)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "postfixish"  :subid("34_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "postfixish"  :subid("34_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx75_tgt
-    .local int rx75_pos
-    .local int rx75_off
-    .local int rx75_eos
-    .local int rx75_rep
-    .local pmc rx75_cur
-    (rx75_cur, rx75_pos, rx75_tgt) = self."!cursor_start"()
-    rx75_cur."!cursor_debug"("START ", "postfixish")
-    .lex unicode:"$\x{a2}", rx75_cur
+    .local string rx74_tgt
+    .local int rx74_pos
+    .local int rx74_off
+    .local int rx74_eos
+    .local int rx74_rep
+    .local pmc rx74_cur
+    (rx74_cur, rx74_pos, rx74_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx74_cur
     .local pmc match
     .lex "$/", match
-    length rx75_eos, rx75_tgt
-    gt rx75_pos, rx75_eos, rx75_done
-    set rx75_off, 0
-    lt rx75_pos, 2, rx75_start
-    sub rx75_off, rx75_pos, 1
-    substr rx75_tgt, rx75_tgt, rx75_off
-  rx75_start:
+    length rx74_eos, rx74_tgt
+    gt rx74_pos, rx74_eos, rx74_done
+    set rx74_off, 0
+    lt rx74_pos, 2, rx74_start
+    sub rx74_off, rx74_pos, 1
+    substr rx74_tgt, rx74_tgt, rx74_off
+  rx74_start:
+    eq $I10, 1, rx74_restart
+    rx74_cur."!cursor_debug"("START ", "postfixish")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan80_done
-    goto rxscan80_scan
-  rxscan80_loop:
-    ($P10) = rx75_cur."from"()
+    ne $I10, -1, rxscan79_done
+    goto rxscan79_scan
+  rxscan79_loop:
+    ($P10) = rx74_cur."from"()
     inc $P10
-    set rx75_pos, $P10
-    ge rx75_pos, rx75_eos, rxscan80_done
-  rxscan80_scan:
-    set_addr $I10, rxscan80_loop
-    rx75_cur."!mark_push"(0, rx75_pos, $I10)
-  rxscan80_done:
-  alt81_0:
+    set rx74_pos, $P10
+    ge rx74_pos, rx74_eos, rxscan79_done
+  rxscan79_scan:
+    set_addr $I10, rxscan79_loop
+    rx74_cur."!mark_push"(0, rx74_pos, $I10)
+  rxscan79_done:
+  alt80_0:
 .annotate 'line', 24
-    set_addr $I10, alt81_1
-    rx75_cur."!mark_push"(0, rx75_pos, $I10)
+    set_addr $I10, alt80_1
+    rx74_cur."!mark_push"(0, rx74_pos, $I10)
 .annotate 'line', 25
   # rx subrule "postfix" subtype=capture negate=
-    rx75_cur."!cursor_pos"(rx75_pos)
-    $P10 = rx75_cur."postfix"()
-    unless $P10, rx75_fail
-    rx75_cur."!mark_push"(0, -1, 0, $P10)
+    rx74_cur."!cursor_pos"(rx74_pos)
+    $P10 = rx74_cur."postfix"()
+    unless $P10, rx74_fail
+    rx74_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("OPER=postfix")
-    rx75_pos = $P10."pos"()
-    goto alt81_end
-  alt81_1:
+    rx74_pos = $P10."pos"()
+    goto alt80_end
+  alt80_1:
 .annotate 'line', 26
   # rx subrule "postcircumfix" subtype=capture negate=
-    rx75_cur."!cursor_pos"(rx75_pos)
-    $P10 = rx75_cur."postcircumfix"()
-    unless $P10, rx75_fail
-    rx75_cur."!mark_push"(0, -1, 0, $P10)
+    rx74_cur."!cursor_pos"(rx74_pos)
+    $P10 = rx74_cur."postcircumfix"()
+    unless $P10, rx74_fail
+    rx74_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("OPER=postcircumfix")
-    rx75_pos = $P10."pos"()
-  alt81_end:
+    rx74_pos = $P10."pos"()
+  alt80_end:
 .annotate 'line', 24
   # rx pass
-    rx75_cur."!cursor_pass"(rx75_pos, "postfixish")
-    rx75_cur."!cursor_debug"("PASS  ", "postfixish", " at pos=", rx75_pos)
-    .return (rx75_cur)
-  rx75_fail:
+    rx74_cur."!cursor_pass"(rx74_pos, "postfixish")
+    rx74_cur."!cursor_debug"("PASS  ", "postfixish", " at pos=", rx74_pos)
+    .return (rx74_cur)
+  rx74_restart:
 .annotate 'line', 5
-    (rx75_rep, rx75_pos, $I10, $P10) = rx75_cur."!mark_fail"(0)
-    lt rx75_pos, -1, rx75_done
-    eq rx75_pos, -1, rx75_fail
+    rx74_cur."!cursor_debug"("NEXT ", "postfixish")
+  rx74_fail:
+    (rx74_rep, rx74_pos, $I10, $P10) = rx74_cur."!mark_fail"(0)
+    lt rx74_pos, -1, rx74_done
+    eq rx74_pos, -1, rx74_fail
     jump $I10
-  rx75_done:
-    rx75_cur."!cursor_fail"()
-    rx75_cur."!cursor_debug"("FAIL  ", "postfixish")
-    .return (rx75_cur)
+  rx74_done:
+    rx74_cur."!cursor_fail"()
+    rx74_cur."!cursor_debug"("FAIL  ", "postfixish")
+    .return (rx74_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__postfixish"  :subid("35_1278500527.62277") :method
+.sub "!PREFIX__postfixish"  :subid("35_1279529214.68208") :method
 .annotate 'line', 5
-    $P77 = self."!PREFIX__!subrule"("postcircumfix", "")
-    $P78 = self."!PREFIX__!subrule"("postfix", "")
-    new $P79, "ResizablePMCArray"
-    push $P79, $P77
-    push $P79, $P78
-    .return ($P79)
+    $P76 = self."!PREFIX__!subrule"("postcircumfix", "")
+    $P77 = self."!PREFIX__!subrule"("postfix", "")
+    new $P78, "ResizablePMCArray"
+    push $P78, $P76
+    push $P78, $P77
+    .return ($P78)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "nullterm"  :subid("36_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "nullterm"  :subid("36_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx83_tgt
-    .local int rx83_pos
-    .local int rx83_off
-    .local int rx83_eos
-    .local int rx83_rep
-    .local pmc rx83_cur
-    (rx83_cur, rx83_pos, rx83_tgt) = self."!cursor_start"()
-    rx83_cur."!cursor_debug"("START ", "nullterm")
-    .lex unicode:"$\x{a2}", rx83_cur
+    .local string rx82_tgt
+    .local int rx82_pos
+    .local int rx82_off
+    .local int rx82_eos
+    .local int rx82_rep
+    .local pmc rx82_cur
+    (rx82_cur, rx82_pos, rx82_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx82_cur
     .local pmc match
     .lex "$/", match
-    length rx83_eos, rx83_tgt
-    gt rx83_pos, rx83_eos, rx83_done
-    set rx83_off, 0
-    lt rx83_pos, 2, rx83_start
-    sub rx83_off, rx83_pos, 1
-    substr rx83_tgt, rx83_tgt, rx83_off
-  rx83_start:
+    length rx82_eos, rx82_tgt
+    gt rx82_pos, rx82_eos, rx82_done
+    set rx82_off, 0
+    lt rx82_pos, 2, rx82_start
+    sub rx82_off, rx82_pos, 1
+    substr rx82_tgt, rx82_tgt, rx82_off
+  rx82_start:
+    eq $I10, 1, rx82_restart
+    rx82_cur."!cursor_debug"("START ", "nullterm")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan86_done
-    goto rxscan86_scan
-  rxscan86_loop:
-    ($P10) = rx83_cur."from"()
+    ne $I10, -1, rxscan85_done
+    goto rxscan85_scan
+  rxscan85_loop:
+    ($P10) = rx82_cur."from"()
     inc $P10
-    set rx83_pos, $P10
-    ge rx83_pos, rx83_eos, rxscan86_done
-  rxscan86_scan:
-    set_addr $I10, rxscan86_loop
-    rx83_cur."!mark_push"(0, rx83_pos, $I10)
-  rxscan86_done:
+    set rx82_pos, $P10
+    ge rx82_pos, rx82_eos, rxscan85_done
+  rxscan85_scan:
+    set_addr $I10, rxscan85_loop
+    rx82_cur."!mark_push"(0, rx82_pos, $I10)
+  rxscan85_done:
 .annotate 'line', 29
   # rx pass
-    rx83_cur."!cursor_pass"(rx83_pos, "nullterm")
-    rx83_cur."!cursor_debug"("PASS  ", "nullterm", " at pos=", rx83_pos)
-    .return (rx83_cur)
-  rx83_fail:
+    rx82_cur."!cursor_pass"(rx82_pos, "nullterm")
+    rx82_cur."!cursor_debug"("PASS  ", "nullterm", " at pos=", rx82_pos)
+    .return (rx82_cur)
+  rx82_restart:
 .annotate 'line', 5
-    (rx83_rep, rx83_pos, $I10, $P10) = rx83_cur."!mark_fail"(0)
-    lt rx83_pos, -1, rx83_done
-    eq rx83_pos, -1, rx83_fail
+    rx82_cur."!cursor_debug"("NEXT ", "nullterm")
+  rx82_fail:
+    (rx82_rep, rx82_pos, $I10, $P10) = rx82_cur."!mark_fail"(0)
+    lt rx82_pos, -1, rx82_done
+    eq rx82_pos, -1, rx82_fail
     jump $I10
-  rx83_done:
-    rx83_cur."!cursor_fail"()
-    rx83_cur."!cursor_debug"("FAIL  ", "nullterm")
-    .return (rx83_cur)
+  rx82_done:
+    rx82_cur."!cursor_fail"()
+    rx82_cur."!cursor_debug"("FAIL  ", "nullterm")
+    .return (rx82_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__nullterm"  :subid("37_1278500527.62277") :method
+.sub "!PREFIX__nullterm"  :subid("37_1279529214.68208") :method
 .annotate 'line', 5
-    new $P85, "ResizablePMCArray"
-    push $P85, ""
-    .return ($P85)
+    new $P84, "ResizablePMCArray"
+    push $P84, ""
+    .return ($P84)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "nullterm_alt"  :subid("38_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "nullterm_alt"  :subid("38_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 5
-    .local string rx88_tgt
-    .local int rx88_pos
-    .local int rx88_off
-    .local int rx88_eos
-    .local int rx88_rep
-    .local pmc rx88_cur
-    (rx88_cur, rx88_pos, rx88_tgt) = self."!cursor_start"()
-    rx88_cur."!cursor_debug"("START ", "nullterm_alt")
-    .lex unicode:"$\x{a2}", rx88_cur
+    .local string rx87_tgt
+    .local int rx87_pos
+    .local int rx87_off
+    .local int rx87_eos
+    .local int rx87_rep
+    .local pmc rx87_cur
+    (rx87_cur, rx87_pos, rx87_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx87_cur
     .local pmc match
     .lex "$/", match
-    length rx88_eos, rx88_tgt
-    gt rx88_pos, rx88_eos, rx88_done
-    set rx88_off, 0
-    lt rx88_pos, 2, rx88_start
-    sub rx88_off, rx88_pos, 1
-    substr rx88_tgt, rx88_tgt, rx88_off
-  rx88_start:
+    length rx87_eos, rx87_tgt
+    gt rx87_pos, rx87_eos, rx87_done
+    set rx87_off, 0
+    lt rx87_pos, 2, rx87_start
+    sub rx87_off, rx87_pos, 1
+    substr rx87_tgt, rx87_tgt, rx87_off
+  rx87_start:
+    eq $I10, 1, rx87_restart
+    rx87_cur."!cursor_debug"("START ", "nullterm_alt")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan92_done
-    goto rxscan92_scan
-  rxscan92_loop:
-    ($P10) = rx88_cur."from"()
+    ne $I10, -1, rxscan91_done
+    goto rxscan91_scan
+  rxscan91_loop:
+    ($P10) = rx87_cur."from"()
     inc $P10
-    set rx88_pos, $P10
-    ge rx88_pos, rx88_eos, rxscan92_done
-  rxscan92_scan:
-    set_addr $I10, rxscan92_loop
-    rx88_cur."!mark_push"(0, rx88_pos, $I10)
-  rxscan92_done:
+    set rx87_pos, $P10
+    ge rx87_pos, rx87_eos, rxscan91_done
+  rxscan91_scan:
+    set_addr $I10, rxscan91_loop
+    rx87_cur."!mark_push"(0, rx87_pos, $I10)
+  rxscan91_done:
 .annotate 'line', 30
   # rx subrule "nullterm" subtype=capture negate=
-    rx88_cur."!cursor_pos"(rx88_pos)
-    $P10 = rx88_cur."nullterm"()
-    unless $P10, rx88_fail
-    rx88_cur."!mark_push"(0, -1, 0, $P10)
+    rx87_cur."!cursor_pos"(rx87_pos)
+    $P10 = rx87_cur."nullterm"()
+    unless $P10, rx87_fail
+    rx87_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("term")
-    rx88_pos = $P10."pos"()
+    rx87_pos = $P10."pos"()
   # rx pass
-    rx88_cur."!cursor_pass"(rx88_pos, "nullterm_alt")
-    rx88_cur."!cursor_debug"("PASS  ", "nullterm_alt", " at pos=", rx88_pos)
-    .return (rx88_cur)
-  rx88_fail:
+    rx87_cur."!cursor_pass"(rx87_pos, "nullterm_alt")
+    rx87_cur."!cursor_debug"("PASS  ", "nullterm_alt", " at pos=", rx87_pos)
+    .return (rx87_cur)
+  rx87_restart:
 .annotate 'line', 5
-    (rx88_rep, rx88_pos, $I10, $P10) = rx88_cur."!mark_fail"(0)
-    lt rx88_pos, -1, rx88_done
-    eq rx88_pos, -1, rx88_fail
+    rx87_cur."!cursor_debug"("NEXT ", "nullterm_alt")
+  rx87_fail:
+    (rx87_rep, rx87_pos, $I10, $P10) = rx87_cur."!mark_fail"(0)
+    lt rx87_pos, -1, rx87_done
+    eq rx87_pos, -1, rx87_fail
     jump $I10
-  rx88_done:
-    rx88_cur."!cursor_fail"()
-    rx88_cur."!cursor_debug"("FAIL  ", "nullterm_alt")
-    .return (rx88_cur)
+  rx87_done:
+    rx87_cur."!cursor_fail"()
+    rx87_cur."!cursor_debug"("FAIL  ", "nullterm_alt")
+    .return (rx87_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__nullterm_alt"  :subid("39_1278500527.62277") :method
+.sub "!PREFIX__nullterm_alt"  :subid("39_1279529214.68208") :method
 .annotate 'line', 5
-    $P90 = self."!PREFIX__!subrule"("nullterm", "")
-    new $P91, "ResizablePMCArray"
-    push $P91, $P90
-    .return ($P91)
+    $P89 = self."!PREFIX__!subrule"("nullterm", "")
+    new $P90, "ResizablePMCArray"
+    push $P90, $P89
+    .return ($P90)
 .end
 
 
 .namespace ["HLL";"Grammar"]
 .include "except_types.pasm"
-.sub "nulltermish"  :subid("40_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "nulltermish"  :subid("40_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    new $P95, 'ExceptionHandler'
-    set_addr $P95, control_94
-    $P95."handle_types"(.CONTROL_RETURN)
-    push_eh $P95
-    .lex "self", self
-    find_lex $P98, "self"
-    $P99 = $P98."termish"()
-    unless $P99, unless_97
-    set $P96, $P99
-    goto unless_97_end
-  unless_97:
-    find_lex $P100, "self"
-    $P101 = $P100."nullterm_alt"()
-    set $P96, $P101
-  unless_97_end:
-    .return ($P96)
-  control_94:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P102, exception, "payload"
-    .return ($P102)
+    new $P94, 'ExceptionHandler'
+    set_addr $P94, control_93
+    $P94."handle_types"(.CONTROL_RETURN)
+    push_eh $P94
+    .lex "self", self
+    find_lex $P97, "self"
+    $P98 = $P97."termish"()
+    unless $P98, unless_96
+    set $P95, $P98
+    goto unless_96_end
+  unless_96:
+    find_lex $P99, "self"
+    $P100 = $P99."nullterm_alt"()
+    set $P95, $P100
+  unless_96_end:
+    .return ($P95)
+  control_93:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P101, exception, "payload"
+    .return ($P101)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_delimited"  :subid("41_1278500527.62277") :method :outer("11_1278500527.62277")
-.annotate 'line', 33
-    .local string rx104_tgt
-    .local int rx104_pos
-    .local int rx104_off
-    .local int rx104_eos
-    .local int rx104_rep
-    .local pmc rx104_cur
-    (rx104_cur, rx104_pos, rx104_tgt) = self."!cursor_start"()
-    rx104_cur."!cursor_debug"("START ", "quote_delimited")
-    rx104_cur."!cursor_caparray"("quote_atom")
-    .lex unicode:"$\x{a2}", rx104_cur
+.sub "quote_delimited"  :subid("41_1279529214.68208") :method :outer("11_1279529214.68208")
+.annotate 'line', 33
+    .local string rx103_tgt
+    .local int rx103_pos
+    .local int rx103_off
+    .local int rx103_eos
+    .local int rx103_rep
+    .local pmc rx103_cur
+    (rx103_cur, rx103_pos, rx103_tgt, $I10) = self."!cursor_start"()
+    rx103_cur."!cursor_caparray"("quote_atom")
+    .lex unicode:"$\x{a2}", rx103_cur
     .local pmc match
     .lex "$/", match
-    length rx104_eos, rx104_tgt
-    gt rx104_pos, rx104_eos, rx104_done
-    set rx104_off, 0
-    lt rx104_pos, 2, rx104_start
-    sub rx104_off, rx104_pos, 1
-    substr rx104_tgt, rx104_tgt, rx104_off
-  rx104_start:
+    length rx103_eos, rx103_tgt
+    gt rx103_pos, rx103_eos, rx103_done
+    set rx103_off, 0
+    lt rx103_pos, 2, rx103_start
+    sub rx103_off, rx103_pos, 1
+    substr rx103_tgt, rx103_tgt, rx103_off
+  rx103_start:
+    eq $I10, 1, rx103_restart
+    rx103_cur."!cursor_debug"("START ", "quote_delimited")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan108_done
-    goto rxscan108_scan
-  rxscan108_loop:
-    ($P10) = rx104_cur."from"()
+    ne $I10, -1, rxscan107_done
+    goto rxscan107_scan
+  rxscan107_loop:
+    ($P10) = rx103_cur."from"()
     inc $P10
-    set rx104_pos, $P10
-    ge rx104_pos, rx104_eos, rxscan108_done
-  rxscan108_scan:
-    set_addr $I10, rxscan108_loop
-    rx104_cur."!mark_push"(0, rx104_pos, $I10)
-  rxscan108_done:
+    set rx103_pos, $P10
+    ge rx103_pos, rx103_eos, rxscan107_done
+  rxscan107_scan:
+    set_addr $I10, rxscan107_loop
+    rx103_cur."!mark_push"(0, rx103_pos, $I10)
+  rxscan107_done:
 .annotate 'line', 37
   # rx subrule "starter" subtype=capture negate=
-    rx104_cur."!cursor_pos"(rx104_pos)
-    $P10 = rx104_cur."starter"()
-    unless $P10, rx104_fail
-    rx104_cur."!mark_push"(0, -1, 0, $P10)
+    rx103_cur."!cursor_pos"(rx103_pos)
+    $P10 = rx103_cur."starter"()
+    unless $P10, rx103_fail
+    rx103_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("starter")
-    rx104_pos = $P10."pos"()
-  # rx rxquantr109 ** 0..*
-    set_addr $I110, rxquantr109_done
-    rx104_cur."!mark_push"(0, rx104_pos, $I110)
-  rxquantr109_loop:
+    rx103_pos = $P10."pos"()
+  # rx rxquantr108 ** 0..*
+    set_addr $I10, rxquantr108_done
+    rx103_cur."!mark_push"(0, rx103_pos, $I10)
+  rxquantr108_loop:
   # rx subrule "quote_atom" subtype=capture negate=
-    rx104_cur."!cursor_pos"(rx104_pos)
-    $P10 = rx104_cur."quote_atom"()
-    unless $P10, rx104_fail
-    rx104_cur."!mark_push"(0, -1, 0, $P10)
+    rx103_cur."!cursor_pos"(rx103_pos)
+    $P10 = rx103_cur."quote_atom"()
+    unless $P10, rx103_fail
+    goto rxsubrule109_pass
+  rxsubrule109_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx103_fail
+  rxsubrule109_pass:
+    set_addr $I10, rxsubrule109_back
+    rx103_cur."!mark_push"(0, rx103_pos, $I10, $P10)
     $P10."!cursor_names"("quote_atom")
-    rx104_pos = $P10."pos"()
-    (rx104_rep) = rx104_cur."!mark_commit"($I110)
-    rx104_cur."!mark_push"(rx104_rep, rx104_pos, $I110)
-    goto rxquantr109_loop
-  rxquantr109_done:
+    rx103_pos = $P10."pos"()
+    set_addr $I10, rxquantr108_done
+    (rx103_rep) = rx103_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr108_done
+    rx103_cur."!mark_push"(rx103_rep, rx103_pos, $I10)
+    goto rxquantr108_loop
+  rxquantr108_done:
   # rx subrule "stopper" subtype=capture negate=
-    rx104_cur."!cursor_pos"(rx104_pos)
-    $P10 = rx104_cur."stopper"()
-    unless $P10, rx104_fail
-    rx104_cur."!mark_push"(0, -1, 0, $P10)
+    rx103_cur."!cursor_pos"(rx103_pos)
+    $P10 = rx103_cur."stopper"()
+    unless $P10, rx103_fail
+    rx103_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("stopper")
-    rx104_pos = $P10."pos"()
+    rx103_pos = $P10."pos"()
 .annotate 'line', 36
   # rx pass
-    rx104_cur."!cursor_pass"(rx104_pos, "quote_delimited")
-    rx104_cur."!cursor_debug"("PASS  ", "quote_delimited", " at pos=", rx104_pos)
-    .return (rx104_cur)
-  rx104_fail:
-.annotate 'line', 33
-    (rx104_rep, rx104_pos, $I10, $P10) = rx104_cur."!mark_fail"(0)
-    lt rx104_pos, -1, rx104_done
-    eq rx104_pos, -1, rx104_fail
+    rx103_cur."!cursor_pass"(rx103_pos, "quote_delimited")
+    rx103_cur."!cursor_debug"("PASS  ", "quote_delimited", " at pos=", rx103_pos)
+    .return (rx103_cur)
+  rx103_restart:
+.annotate 'line', 33
+    rx103_cur."!cursor_debug"("NEXT ", "quote_delimited")
+  rx103_fail:
+    (rx103_rep, rx103_pos, $I10, $P10) = rx103_cur."!mark_fail"(0)
+    lt rx103_pos, -1, rx103_done
+    eq rx103_pos, -1, rx103_fail
     jump $I10
-  rx104_done:
-    rx104_cur."!cursor_fail"()
-    rx104_cur."!cursor_debug"("FAIL  ", "quote_delimited")
-    .return (rx104_cur)
+  rx103_done:
+    rx103_cur."!cursor_fail"()
+    rx103_cur."!cursor_debug"("FAIL  ", "quote_delimited")
+    .return (rx103_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_delimited"  :subid("42_1278500527.62277") :method
+.sub "!PREFIX__quote_delimited"  :subid("42_1279529214.68208") :method
 .annotate 'line', 33
-    $P106 = self."!PREFIX__!subrule"("starter", "")
-    new $P107, "ResizablePMCArray"
-    push $P107, $P106
-    .return ($P107)
+    $P105 = self."!PREFIX__!subrule"("starter", "")
+    new $P106, "ResizablePMCArray"
+    push $P106, $P105
+    .return ($P106)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_atom"  :subid("43_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_atom"  :subid("43_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx112_tgt
-    .local int rx112_pos
-    .local int rx112_off
-    .local int rx112_eos
-    .local int rx112_rep
-    .local pmc rx112_cur
-    (rx112_cur, rx112_pos, rx112_tgt) = self."!cursor_start"()
-    rx112_cur."!cursor_debug"("START ", "quote_atom")
-    .lex unicode:"$\x{a2}", rx112_cur
+    .local string rx111_tgt
+    .local int rx111_pos
+    .local int rx111_off
+    .local int rx111_eos
+    .local int rx111_rep
+    .local pmc rx111_cur
+    (rx111_cur, rx111_pos, rx111_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx111_cur
     .local pmc match
     .lex "$/", match
-    length rx112_eos, rx112_tgt
-    gt rx112_pos, rx112_eos, rx112_done
-    set rx112_off, 0
-    lt rx112_pos, 2, rx112_start
-    sub rx112_off, rx112_pos, 1
-    substr rx112_tgt, rx112_tgt, rx112_off
-  rx112_start:
+    length rx111_eos, rx111_tgt
+    gt rx111_pos, rx111_eos, rx111_done
+    set rx111_off, 0
+    lt rx111_pos, 2, rx111_start
+    sub rx111_off, rx111_pos, 1
+    substr rx111_tgt, rx111_tgt, rx111_off
+  rx111_start:
+    eq $I10, 1, rx111_restart
+    rx111_cur."!cursor_debug"("START ", "quote_atom")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan115_done
-    goto rxscan115_scan
-  rxscan115_loop:
-    ($P10) = rx112_cur."from"()
+    ne $I10, -1, rxscan114_done
+    goto rxscan114_scan
+  rxscan114_loop:
+    ($P10) = rx111_cur."from"()
     inc $P10
-    set rx112_pos, $P10
-    ge rx112_pos, rx112_eos, rxscan115_done
-  rxscan115_scan:
-    set_addr $I10, rxscan115_loop
-    rx112_cur."!mark_push"(0, rx112_pos, $I10)
-  rxscan115_done:
+    set rx111_pos, $P10
+    ge rx111_pos, rx111_eos, rxscan114_done
+  rxscan114_scan:
+    set_addr $I10, rxscan114_loop
+    rx111_cur."!mark_push"(0, rx111_pos, $I10)
+  rxscan114_done:
 .annotate 'line', 41
   # rx subrule "stopper" subtype=zerowidth negate=1
-    rx112_cur."!cursor_pos"(rx112_pos)
-    $P10 = rx112_cur."stopper"()
-    if $P10, rx112_fail
-  alt116_0:
+    rx111_cur."!cursor_pos"(rx111_pos)
+    $P10 = rx111_cur."stopper"()
+    if $P10, rx111_fail
+  alt115_0:
 .annotate 'line', 42
-    set_addr $I10, alt116_1
-    rx112_cur."!mark_push"(0, rx112_pos, $I10)
+    set_addr $I10, alt115_1
+    rx111_cur."!mark_push"(0, rx111_pos, $I10)
 .annotate 'line', 43
   # rx subrule "quote_escape" subtype=capture negate=
-    rx112_cur."!cursor_pos"(rx112_pos)
-    $P10 = rx112_cur."quote_escape"()
-    unless $P10, rx112_fail
-    rx112_cur."!mark_push"(0, -1, 0, $P10)
+    rx111_cur."!cursor_pos"(rx111_pos)
+    $P10 = rx111_cur."quote_escape"()
+    unless $P10, rx111_fail
+    rx111_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_escape")
-    rx112_pos = $P10."pos"()
-    goto alt116_end
-  alt116_1:
+    rx111_pos = $P10."pos"()
+    goto alt115_end
+  alt115_1:
 .annotate 'line', 44
-  # rx rxquantr117 ** 1..*
-    set_addr $I120, rxquantr117_done
-    rx112_cur."!mark_push"(0, -1, $I120)
-  rxquantr117_loop:
+  # rx rxquantr116 ** 1..*
+    set_addr $I10, rxquantr116_done
+    rx111_cur."!mark_push"(0, -1, $I10)
+  rxquantr116_loop:
   # rx subrule "stopper" subtype=zerowidth negate=1
-    rx112_cur."!cursor_pos"(rx112_pos)
-    $P10 = rx112_cur."stopper"()
-    if $P10, rx112_fail
+    rx111_cur."!cursor_pos"(rx111_pos)
+    $P10 = rx111_cur."stopper"()
+    if $P10, rx111_fail
   # rx subrule "quote_escape" subtype=zerowidth negate=1
-    rx112_cur."!cursor_pos"(rx112_pos)
-    $P10 = rx112_cur."quote_escape"()
-    if $P10, rx112_fail
+    rx111_cur."!cursor_pos"(rx111_pos)
+    $P10 = rx111_cur."quote_escape"()
+    if $P10, rx111_fail
   # rx charclass .
-    ge rx112_pos, rx112_eos, rx112_fail
-    inc rx112_pos
-    (rx112_rep) = rx112_cur."!mark_commit"($I120)
-    rx112_cur."!mark_push"(rx112_rep, rx112_pos, $I120)
-    goto rxquantr117_loop
-  rxquantr117_done:
-  alt116_end:
+    ge rx111_pos, rx111_eos, rx111_fail
+    inc rx111_pos
+    set_addr $I10, rxquantr116_done
+    (rx111_rep) = rx111_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr116_done
+    rx111_cur."!mark_push"(rx111_rep, rx111_pos, $I10)
+    goto rxquantr116_loop
+  rxquantr116_done:
+  alt115_end:
 .annotate 'line', 40
   # rx pass
-    rx112_cur."!cursor_pass"(rx112_pos, "quote_atom")
-    rx112_cur."!cursor_debug"("PASS  ", "quote_atom", " at pos=", rx112_pos)
-    .return (rx112_cur)
-  rx112_fail:
-.annotate 'line', 33
-    (rx112_rep, rx112_pos, $I10, $P10) = rx112_cur."!mark_fail"(0)
-    lt rx112_pos, -1, rx112_done
-    eq rx112_pos, -1, rx112_fail
+    rx111_cur."!cursor_pass"(rx111_pos, "quote_atom")
+    rx111_cur."!cursor_debug"("PASS  ", "quote_atom", " at pos=", rx111_pos)
+    .return (rx111_cur)
+  rx111_restart:
+.annotate 'line', 33
+    rx111_cur."!cursor_debug"("NEXT ", "quote_atom")
+  rx111_fail:
+    (rx111_rep, rx111_pos, $I10, $P10) = rx111_cur."!mark_fail"(0)
+    lt rx111_pos, -1, rx111_done
+    eq rx111_pos, -1, rx111_fail
     jump $I10
-  rx112_done:
-    rx112_cur."!cursor_fail"()
-    rx112_cur."!cursor_debug"("FAIL  ", "quote_atom")
-    .return (rx112_cur)
+  rx111_done:
+    rx111_cur."!cursor_fail"()
+    rx111_cur."!cursor_debug"("FAIL  ", "quote_atom")
+    .return (rx111_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_atom"  :subid("44_1278500527.62277") :method
+.sub "!PREFIX__quote_atom"  :subid("44_1279529214.68208") :method
 .annotate 'line', 33
-    new $P114, "ResizablePMCArray"
-    push $P114, ""
-    .return ($P114)
+    new $P113, "ResizablePMCArray"
+    push $P113, ""
+    .return ($P113)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "decint"  :subid("45_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "decint"  :subid("45_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx122_tgt
-    .local int rx122_pos
-    .local int rx122_off
-    .local int rx122_eos
-    .local int rx122_rep
-    .local pmc rx122_cur
-    (rx122_cur, rx122_pos, rx122_tgt) = self."!cursor_start"()
-    rx122_cur."!cursor_debug"("START ", "decint")
-    .lex unicode:"$\x{a2}", rx122_cur
+    .local string rx120_tgt
+    .local int rx120_pos
+    .local int rx120_off
+    .local int rx120_eos
+    .local int rx120_rep
+    .local pmc rx120_cur
+    (rx120_cur, rx120_pos, rx120_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx120_cur
     .local pmc match
     .lex "$/", match
-    length rx122_eos, rx122_tgt
-    gt rx122_pos, rx122_eos, rx122_done
-    set rx122_off, 0
-    lt rx122_pos, 2, rx122_start
-    sub rx122_off, rx122_pos, 1
-    substr rx122_tgt, rx122_tgt, rx122_off
-  rx122_start:
+    length rx120_eos, rx120_tgt
+    gt rx120_pos, rx120_eos, rx120_done
+    set rx120_off, 0
+    lt rx120_pos, 2, rx120_start
+    sub rx120_off, rx120_pos, 1
+    substr rx120_tgt, rx120_tgt, rx120_off
+  rx120_start:
+    eq $I10, 1, rx120_restart
+    rx120_cur."!cursor_debug"("START ", "decint")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan125_done
-    goto rxscan125_scan
-  rxscan125_loop:
-    ($P10) = rx122_cur."from"()
+    ne $I10, -1, rxscan123_done
+    goto rxscan123_scan
+  rxscan123_loop:
+    ($P10) = rx120_cur."from"()
     inc $P10
-    set rx122_pos, $P10
-    ge rx122_pos, rx122_eos, rxscan125_done
-  rxscan125_scan:
-    set_addr $I10, rxscan125_loop
-    rx122_cur."!mark_push"(0, rx122_pos, $I10)
-  rxscan125_done:
+    set rx120_pos, $P10
+    ge rx120_pos, rx120_eos, rxscan123_done
+  rxscan123_scan:
+    set_addr $I10, rxscan123_loop
+    rx120_cur."!mark_push"(0, rx120_pos, $I10)
+  rxscan123_done:
 .annotate 'line', 48
-  # rx rxquantr126 ** 1..*
-    set_addr $I127, rxquantr126_done
-    rx122_cur."!mark_push"(0, -1, $I127)
-  rxquantr126_loop:
+  # rx rxquantr124 ** 1..*
+    set_addr $I10, rxquantr124_done
+    rx120_cur."!mark_push"(0, -1, $I10)
+  rxquantr124_loop:
   # rx charclass_q d r 1..-1
-    sub $I10, rx122_pos, rx122_off
-    find_not_cclass $I11, 8, rx122_tgt, $I10, rx122_eos
+    sub $I10, rx120_pos, rx120_off
+    find_not_cclass $I11, 8, rx120_tgt, $I10, rx120_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx122_fail
-    add rx122_pos, rx122_off, $I11
-    (rx122_rep) = rx122_cur."!mark_commit"($I127)
-    rx122_cur."!mark_push"(rx122_rep, rx122_pos, $I127)
+    lt $I11, $I12, rx120_fail
+    add rx120_pos, rx120_off, $I11
+    set_addr $I10, rxquantr124_done
+    (rx120_rep) = rx120_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr124_done
+    rx120_cur."!mark_push"(rx120_rep, rx120_pos, $I10)
   # rx literal  "_"
-    add $I11, rx122_pos, 1
-    gt $I11, rx122_eos, rx122_fail
-    sub $I11, rx122_pos, rx122_off
-    substr $S10, rx122_tgt, $I11, 1
-    ne $S10, "_", rx122_fail
-    add rx122_pos, 1
-    goto rxquantr126_loop
-  rxquantr126_done:
+    add $I11, rx120_pos, 1
+    gt $I11, rx120_eos, rx120_fail
+    sub $I11, rx120_pos, rx120_off
+    substr $S10, rx120_tgt, $I11, 1
+    ne $S10, "_", rx120_fail
+    add rx120_pos, 1
+    goto rxquantr124_loop
+  rxquantr124_done:
   # rx pass
-    rx122_cur."!cursor_pass"(rx122_pos, "decint")
-    rx122_cur."!cursor_debug"("PASS  ", "decint", " at pos=", rx122_pos)
-    .return (rx122_cur)
-  rx122_fail:
-.annotate 'line', 33
-    (rx122_rep, rx122_pos, $I10, $P10) = rx122_cur."!mark_fail"(0)
-    lt rx122_pos, -1, rx122_done
-    eq rx122_pos, -1, rx122_fail
+    rx120_cur."!cursor_pass"(rx120_pos, "decint")
+    rx120_cur."!cursor_debug"("PASS  ", "decint", " at pos=", rx120_pos)
+    .return (rx120_cur)
+  rx120_restart:
+.annotate 'line', 33
+    rx120_cur."!cursor_debug"("NEXT ", "decint")
+  rx120_fail:
+    (rx120_rep, rx120_pos, $I10, $P10) = rx120_cur."!mark_fail"(0)
+    lt rx120_pos, -1, rx120_done
+    eq rx120_pos, -1, rx120_fail
     jump $I10
-  rx122_done:
-    rx122_cur."!cursor_fail"()
-    rx122_cur."!cursor_debug"("FAIL  ", "decint")
-    .return (rx122_cur)
+  rx120_done:
+    rx120_cur."!cursor_fail"()
+    rx120_cur."!cursor_debug"("FAIL  ", "decint")
+    .return (rx120_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__decint"  :subid("46_1278500527.62277") :method
+.sub "!PREFIX__decint"  :subid("46_1279529214.68208") :method
 .annotate 'line', 33
-    new $P124, "ResizablePMCArray"
-    push $P124, ""
-    .return ($P124)
+    new $P122, "ResizablePMCArray"
+    push $P122, ""
+    .return ($P122)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "decints"  :subid("47_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "decints"  :subid("47_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx129_tgt
-    .local int rx129_pos
-    .local int rx129_off
-    .local int rx129_eos
-    .local int rx129_rep
-    .local pmc rx129_cur
-    (rx129_cur, rx129_pos, rx129_tgt) = self."!cursor_start"()
-    rx129_cur."!cursor_debug"("START ", "decints")
-    rx129_cur."!cursor_caparray"("decint")
-    .lex unicode:"$\x{a2}", rx129_cur
+    .local string rx126_tgt
+    .local int rx126_pos
+    .local int rx126_off
+    .local int rx126_eos
+    .local int rx126_rep
+    .local pmc rx126_cur
+    (rx126_cur, rx126_pos, rx126_tgt, $I10) = self."!cursor_start"()
+    rx126_cur."!cursor_caparray"("decint")
+    .lex unicode:"$\x{a2}", rx126_cur
     .local pmc match
     .lex "$/", match
-    length rx129_eos, rx129_tgt
-    gt rx129_pos, rx129_eos, rx129_done
-    set rx129_off, 0
-    lt rx129_pos, 2, rx129_start
-    sub rx129_off, rx129_pos, 1
-    substr rx129_tgt, rx129_tgt, rx129_off
-  rx129_start:
+    length rx126_eos, rx126_tgt
+    gt rx126_pos, rx126_eos, rx126_done
+    set rx126_off, 0
+    lt rx126_pos, 2, rx126_start
+    sub rx126_off, rx126_pos, 1
+    substr rx126_tgt, rx126_tgt, rx126_off
+  rx126_start:
+    eq $I10, 1, rx126_restart
+    rx126_cur."!cursor_debug"("START ", "decints")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan132_done
-    goto rxscan132_scan
-  rxscan132_loop:
-    ($P10) = rx129_cur."from"()
+    ne $I10, -1, rxscan129_done
+    goto rxscan129_scan
+  rxscan129_loop:
+    ($P10) = rx126_cur."from"()
     inc $P10
-    set rx129_pos, $P10
-    ge rx129_pos, rx129_eos, rxscan132_done
-  rxscan132_scan:
-    set_addr $I10, rxscan132_loop
-    rx129_cur."!mark_push"(0, rx129_pos, $I10)
-  rxscan132_done:
+    set rx126_pos, $P10
+    ge rx126_pos, rx126_eos, rxscan129_done
+  rxscan129_scan:
+    set_addr $I10, rxscan129_loop
+    rx126_cur."!mark_push"(0, rx126_pos, $I10)
+  rxscan129_done:
 .annotate 'line', 49
-  # rx rxquantr133 ** 1..*
-    set_addr $I134, rxquantr133_done
-    rx129_cur."!mark_push"(0, -1, $I134)
-  rxquantr133_loop:
+  # rx rxquantr130 ** 1..*
+    set_addr $I10, rxquantr130_done
+    rx126_cur."!mark_push"(0, -1, $I10)
+  rxquantr130_loop:
   # rx subrule "ws" subtype=method negate=
-    rx129_cur."!cursor_pos"(rx129_pos)
-    $P10 = rx129_cur."ws"()
-    unless $P10, rx129_fail
-    rx129_pos = $P10."pos"()
+    rx126_cur."!cursor_pos"(rx126_pos)
+    $P10 = rx126_cur."ws"()
+    unless $P10, rx126_fail
+    rx126_pos = $P10."pos"()
   # rx subrule "decint" subtype=capture negate=
-    rx129_cur."!cursor_pos"(rx129_pos)
-    $P10 = rx129_cur."decint"()
-    unless $P10, rx129_fail
-    rx129_cur."!mark_push"(0, -1, 0, $P10)
+    rx126_cur."!cursor_pos"(rx126_pos)
+    $P10 = rx126_cur."decint"()
+    unless $P10, rx126_fail
+    rx126_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("decint")
-    rx129_pos = $P10."pos"()
+    rx126_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx129_cur."!cursor_pos"(rx129_pos)
-    $P10 = rx129_cur."ws"()
-    unless $P10, rx129_fail
-    rx129_pos = $P10."pos"()
-    (rx129_rep) = rx129_cur."!mark_commit"($I134)
-    rx129_cur."!mark_push"(rx129_rep, rx129_pos, $I134)
+    rx126_cur."!cursor_pos"(rx126_pos)
+    $P10 = rx126_cur."ws"()
+    unless $P10, rx126_fail
+    rx126_pos = $P10."pos"()
+    set_addr $I10, rxquantr130_done
+    (rx126_rep) = rx126_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr130_done
+    rx126_cur."!mark_push"(rx126_rep, rx126_pos, $I10)
   # rx literal  ","
-    add $I11, rx129_pos, 1
-    gt $I11, rx129_eos, rx129_fail
-    sub $I11, rx129_pos, rx129_off
-    substr $S10, rx129_tgt, $I11, 1
-    ne $S10, ",", rx129_fail
-    add rx129_pos, 1
-    goto rxquantr133_loop
-  rxquantr133_done:
+    add $I11, rx126_pos, 1
+    gt $I11, rx126_eos, rx126_fail
+    sub $I11, rx126_pos, rx126_off
+    substr $S10, rx126_tgt, $I11, 1
+    ne $S10, ",", rx126_fail
+    add rx126_pos, 1
+    goto rxquantr130_loop
+  rxquantr130_done:
   # rx pass
-    rx129_cur."!cursor_pass"(rx129_pos, "decints")
-    rx129_cur."!cursor_debug"("PASS  ", "decints", " at pos=", rx129_pos)
-    .return (rx129_cur)
-  rx129_fail:
-.annotate 'line', 33
-    (rx129_rep, rx129_pos, $I10, $P10) = rx129_cur."!mark_fail"(0)
-    lt rx129_pos, -1, rx129_done
-    eq rx129_pos, -1, rx129_fail
+    rx126_cur."!cursor_pass"(rx126_pos, "decints")
+    rx126_cur."!cursor_debug"("PASS  ", "decints", " at pos=", rx126_pos)
+    .return (rx126_cur)
+  rx126_restart:
+.annotate 'line', 33
+    rx126_cur."!cursor_debug"("NEXT ", "decints")
+  rx126_fail:
+    (rx126_rep, rx126_pos, $I10, $P10) = rx126_cur."!mark_fail"(0)
+    lt rx126_pos, -1, rx126_done
+    eq rx126_pos, -1, rx126_fail
     jump $I10
-  rx129_done:
-    rx129_cur."!cursor_fail"()
-    rx129_cur."!cursor_debug"("FAIL  ", "decints")
-    .return (rx129_cur)
+  rx126_done:
+    rx126_cur."!cursor_fail"()
+    rx126_cur."!cursor_debug"("FAIL  ", "decints")
+    .return (rx126_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__decints"  :subid("48_1278500527.62277") :method
+.sub "!PREFIX__decints"  :subid("48_1279529214.68208") :method
 .annotate 'line', 33
-    new $P131, "ResizablePMCArray"
-    push $P131, ""
-    .return ($P131)
+    new $P128, "ResizablePMCArray"
+    push $P128, ""
+    .return ($P128)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "hexint"  :subid("49_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "hexint"  :subid("49_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx136_tgt
-    .local int rx136_pos
-    .local int rx136_off
-    .local int rx136_eos
-    .local int rx136_rep
-    .local pmc rx136_cur
-    (rx136_cur, rx136_pos, rx136_tgt) = self."!cursor_start"()
-    rx136_cur."!cursor_debug"("START ", "hexint")
-    .lex unicode:"$\x{a2}", rx136_cur
+    .local string rx132_tgt
+    .local int rx132_pos
+    .local int rx132_off
+    .local int rx132_eos
+    .local int rx132_rep
+    .local pmc rx132_cur
+    (rx132_cur, rx132_pos, rx132_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx132_cur
     .local pmc match
     .lex "$/", match
-    length rx136_eos, rx136_tgt
-    gt rx136_pos, rx136_eos, rx136_done
-    set rx136_off, 0
-    lt rx136_pos, 2, rx136_start
-    sub rx136_off, rx136_pos, 1
-    substr rx136_tgt, rx136_tgt, rx136_off
-  rx136_start:
+    length rx132_eos, rx132_tgt
+    gt rx132_pos, rx132_eos, rx132_done
+    set rx132_off, 0
+    lt rx132_pos, 2, rx132_start
+    sub rx132_off, rx132_pos, 1
+    substr rx132_tgt, rx132_tgt, rx132_off
+  rx132_start:
+    eq $I10, 1, rx132_restart
+    rx132_cur."!cursor_debug"("START ", "hexint")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan139_done
-    goto rxscan139_scan
-  rxscan139_loop:
-    ($P10) = rx136_cur."from"()
+    ne $I10, -1, rxscan135_done
+    goto rxscan135_scan
+  rxscan135_loop:
+    ($P10) = rx132_cur."from"()
     inc $P10
-    set rx136_pos, $P10
-    ge rx136_pos, rx136_eos, rxscan139_done
-  rxscan139_scan:
-    set_addr $I10, rxscan139_loop
-    rx136_cur."!mark_push"(0, rx136_pos, $I10)
-  rxscan139_done:
+    set rx132_pos, $P10
+    ge rx132_pos, rx132_eos, rxscan135_done
+  rxscan135_scan:
+    set_addr $I10, rxscan135_loop
+    rx132_cur."!mark_push"(0, rx132_pos, $I10)
+  rxscan135_done:
 .annotate 'line', 51
-  # rx rxquantr140 ** 1..*
-    set_addr $I143, rxquantr140_done
-    rx136_cur."!mark_push"(0, -1, $I143)
-  rxquantr140_loop:
-  # rx rxquantr141 ** 1..*
-    set_addr $I142, rxquantr141_done
-    rx136_cur."!mark_push"(0, -1, $I142)
-  rxquantr141_loop:
+  # rx rxquantr136 ** 1..*
+    set_addr $I10, rxquantr136_done
+    rx132_cur."!mark_push"(0, -1, $I10)
+  rxquantr136_loop:
+  # rx rxquantr137 ** 1..*
+    set_addr $I10, rxquantr137_done
+    rx132_cur."!mark_push"(0, -1, $I10)
+  rxquantr137_loop:
   # rx enumcharlist negate=0 
-    ge rx136_pos, rx136_eos, rx136_fail
-    sub $I10, rx136_pos, rx136_off
-    substr $S10, rx136_tgt, $I10, 1
+    ge rx132_pos, rx132_eos, rx132_fail
+    sub $I10, rx132_pos, rx132_off
+    substr $S10, rx132_tgt, $I10, 1
     index $I11, "0123456789abcdefABCDEF", $S10
-    lt $I11, 0, rx136_fail
-    inc rx136_pos
-    (rx136_rep) = rx136_cur."!mark_commit"($I142)
-    rx136_cur."!mark_push"(rx136_rep, rx136_pos, $I142)
-    goto rxquantr141_loop
-  rxquantr141_done:
-    (rx136_rep) = rx136_cur."!mark_commit"($I143)
-    rx136_cur."!mark_push"(rx136_rep, rx136_pos, $I143)
+    lt $I11, 0, rx132_fail
+    inc rx132_pos
+    set_addr $I10, rxquantr137_done
+    (rx132_rep) = rx132_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr137_done
+    rx132_cur."!mark_push"(rx132_rep, rx132_pos, $I10)
+    goto rxquantr137_loop
+  rxquantr137_done:
+    set_addr $I10, rxquantr136_done
+    (rx132_rep) = rx132_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr136_done
+    rx132_cur."!mark_push"(rx132_rep, rx132_pos, $I10)
   # rx literal  "_"
-    add $I11, rx136_pos, 1
-    gt $I11, rx136_eos, rx136_fail
-    sub $I11, rx136_pos, rx136_off
-    substr $S10, rx136_tgt, $I11, 1
-    ne $S10, "_", rx136_fail
-    add rx136_pos, 1
-    goto rxquantr140_loop
-  rxquantr140_done:
+    add $I11, rx132_pos, 1
+    gt $I11, rx132_eos, rx132_fail
+    sub $I11, rx132_pos, rx132_off
+    substr $S10, rx132_tgt, $I11, 1
+    ne $S10, "_", rx132_fail
+    add rx132_pos, 1
+    goto rxquantr136_loop
+  rxquantr136_done:
+  # rx pass
+    rx132_cur."!cursor_pass"(rx132_pos, "hexint")
+    rx132_cur."!cursor_debug"("PASS  ", "hexint", " at pos=", rx132_pos)
+    .return (rx132_cur)
+  rx132_restart:
+.annotate 'line', 33
+    rx132_cur."!cursor_debug"("NEXT ", "hexint")
+  rx132_fail:
+    (rx132_rep, rx132_pos, $I10, $P10) = rx132_cur."!mark_fail"(0)
+    lt rx132_pos, -1, rx132_done
+    eq rx132_pos, -1, rx132_fail
+    jump $I10
+  rx132_done:
+    rx132_cur."!cursor_fail"()
+    rx132_cur."!cursor_debug"("FAIL  ", "hexint")
+    .return (rx132_cur)
+    .return ()
+.end
+
+
+.namespace ["HLL";"Grammar"]
+.sub "!PREFIX__hexint"  :subid("50_1279529214.68208") :method
+.annotate 'line', 33
+    new $P134, "ResizablePMCArray"
+    push $P134, ""
+    .return ($P134)
+.end
+
+
+.namespace ["HLL";"Grammar"]
+.sub "hexints"  :subid("51_1279529214.68208") :method :outer("11_1279529214.68208")
+.annotate 'line', 33
+    .local string rx139_tgt
+    .local int rx139_pos
+    .local int rx139_off
+    .local int rx139_eos
+    .local int rx139_rep
+    .local pmc rx139_cur
+    (rx139_cur, rx139_pos, rx139_tgt, $I10) = self."!cursor_start"()
+    rx139_cur."!cursor_caparray"("hexint")
+    .lex unicode:"$\x{a2}", rx139_cur
+    .local pmc match
+    .lex "$/", match
+    length rx139_eos, rx139_tgt
+    gt rx139_pos, rx139_eos, rx139_done
+    set rx139_off, 0
+    lt rx139_pos, 2, rx139_start
+    sub rx139_off, rx139_pos, 1
+    substr rx139_tgt, rx139_tgt, rx139_off
+  rx139_start:
+    eq $I10, 1, rx139_restart
+    rx139_cur."!cursor_debug"("START ", "hexints")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan142_done
+    goto rxscan142_scan
+  rxscan142_loop:
+    ($P10) = rx139_cur."from"()
+    inc $P10
+    set rx139_pos, $P10
+    ge rx139_pos, rx139_eos, rxscan142_done
+  rxscan142_scan:
+    set_addr $I10, rxscan142_loop
+    rx139_cur."!mark_push"(0, rx139_pos, $I10)
+  rxscan142_done:
+.annotate 'line', 52
+  # rx rxquantr143 ** 1..*
+    set_addr $I10, rxquantr143_done
+    rx139_cur."!mark_push"(0, -1, $I10)
+  rxquantr143_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx139_cur."!cursor_pos"(rx139_pos)
+    $P10 = rx139_cur."ws"()
+    unless $P10, rx139_fail
+    rx139_pos = $P10."pos"()
+  # rx subrule "hexint" subtype=capture negate=
+    rx139_cur."!cursor_pos"(rx139_pos)
+    $P10 = rx139_cur."hexint"()
+    unless $P10, rx139_fail
+    rx139_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("hexint")
+    rx139_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx139_cur."!cursor_pos"(rx139_pos)
+    $P10 = rx139_cur."ws"()
+    unless $P10, rx139_fail
+    rx139_pos = $P10."pos"()
+    set_addr $I10, rxquantr143_done
+    (rx139_rep) = rx139_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr143_done
+    rx139_cur."!mark_push"(rx139_rep, rx139_pos, $I10)
+  # rx literal  ","
+    add $I11, rx139_pos, 1
+    gt $I11, rx139_eos, rx139_fail
+    sub $I11, rx139_pos, rx139_off
+    substr $S10, rx139_tgt, $I11, 1
+    ne $S10, ",", rx139_fail
+    add rx139_pos, 1
+    goto rxquantr143_loop
+  rxquantr143_done:
   # rx pass
-    rx136_cur."!cursor_pass"(rx136_pos, "hexint")
-    rx136_cur."!cursor_debug"("PASS  ", "hexint", " at pos=", rx136_pos)
-    .return (rx136_cur)
-  rx136_fail:
-.annotate 'line', 33
-    (rx136_rep, rx136_pos, $I10, $P10) = rx136_cur."!mark_fail"(0)
-    lt rx136_pos, -1, rx136_done
-    eq rx136_pos, -1, rx136_fail
+    rx139_cur."!cursor_pass"(rx139_pos, "hexints")
+    rx139_cur."!cursor_debug"("PASS  ", "hexints", " at pos=", rx139_pos)
+    .return (rx139_cur)
+  rx139_restart:
+.annotate 'line', 33
+    rx139_cur."!cursor_debug"("NEXT ", "hexints")
+  rx139_fail:
+    (rx139_rep, rx139_pos, $I10, $P10) = rx139_cur."!mark_fail"(0)
+    lt rx139_pos, -1, rx139_done
+    eq rx139_pos, -1, rx139_fail
     jump $I10
-  rx136_done:
-    rx136_cur."!cursor_fail"()
-    rx136_cur."!cursor_debug"("FAIL  ", "hexint")
-    .return (rx136_cur)
+  rx139_done:
+    rx139_cur."!cursor_fail"()
+    rx139_cur."!cursor_debug"("FAIL  ", "hexints")
+    .return (rx139_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__hexint"  :subid("50_1278500527.62277") :method
+.sub "!PREFIX__hexints"  :subid("52_1279529214.68208") :method
 .annotate 'line', 33
-    new $P138, "ResizablePMCArray"
-    push $P138, ""
-    .return ($P138)
+    new $P141, "ResizablePMCArray"
+    push $P141, ""
+    .return ($P141)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "hexints"  :subid("51_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "octint"  :subid("53_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
     .local string rx145_tgt
     .local int rx145_pos
@@ -2249,9 +2423,7 @@
     .local int rx145_eos
     .local int rx145_rep
     .local pmc rx145_cur
-    (rx145_cur, rx145_pos, rx145_tgt) = self."!cursor_start"()
-    rx145_cur."!cursor_debug"("START ", "hexints")
-    rx145_cur."!cursor_caparray"("hexint")
+    (rx145_cur, rx145_pos, rx145_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx145_cur
     .local pmc match
     .lex "$/", match
@@ -2262,6 +2434,8 @@
     sub rx145_off, rx145_pos, 1
     substr rx145_tgt, rx145_tgt, rx145_off
   rx145_start:
+    eq $I10, 1, rx145_restart
+    rx145_cur."!cursor_debug"("START ", "octint")
     $I10 = self.'from'()
     ne $I10, -1, rxscan148_done
     goto rxscan148_scan
@@ -2274,59 +2448,63 @@
     set_addr $I10, rxscan148_loop
     rx145_cur."!mark_push"(0, rx145_pos, $I10)
   rxscan148_done:
-.annotate 'line', 52
+.annotate 'line', 54
   # rx rxquantr149 ** 1..*
-    set_addr $I150, rxquantr149_done
-    rx145_cur."!mark_push"(0, -1, $I150)
+    set_addr $I10, rxquantr149_done
+    rx145_cur."!mark_push"(0, -1, $I10)
   rxquantr149_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx145_cur."!cursor_pos"(rx145_pos)
-    $P10 = rx145_cur."ws"()
-    unless $P10, rx145_fail
-    rx145_pos = $P10."pos"()
-  # rx subrule "hexint" subtype=capture negate=
-    rx145_cur."!cursor_pos"(rx145_pos)
-    $P10 = rx145_cur."hexint"()
-    unless $P10, rx145_fail
-    rx145_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("hexint")
-    rx145_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx145_cur."!cursor_pos"(rx145_pos)
-    $P10 = rx145_cur."ws"()
-    unless $P10, rx145_fail
-    rx145_pos = $P10."pos"()
-    (rx145_rep) = rx145_cur."!mark_commit"($I150)
-    rx145_cur."!mark_push"(rx145_rep, rx145_pos, $I150)
-  # rx literal  ","
+  # rx rxquantr150 ** 1..*
+    set_addr $I10, rxquantr150_done
+    rx145_cur."!mark_push"(0, -1, $I10)
+  rxquantr150_loop:
+  # rx enumcharlist negate=0 
+    ge rx145_pos, rx145_eos, rx145_fail
+    sub $I10, rx145_pos, rx145_off
+    substr $S10, rx145_tgt, $I10, 1
+    index $I11, "01234567", $S10
+    lt $I11, 0, rx145_fail
+    inc rx145_pos
+    set_addr $I10, rxquantr150_done
+    (rx145_rep) = rx145_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr150_done
+    rx145_cur."!mark_push"(rx145_rep, rx145_pos, $I10)
+    goto rxquantr150_loop
+  rxquantr150_done:
+    set_addr $I10, rxquantr149_done
+    (rx145_rep) = rx145_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr149_done
+    rx145_cur."!mark_push"(rx145_rep, rx145_pos, $I10)
+  # rx literal  "_"
     add $I11, rx145_pos, 1
     gt $I11, rx145_eos, rx145_fail
     sub $I11, rx145_pos, rx145_off
     substr $S10, rx145_tgt, $I11, 1
-    ne $S10, ",", rx145_fail
+    ne $S10, "_", rx145_fail
     add rx145_pos, 1
     goto rxquantr149_loop
   rxquantr149_done:
   # rx pass
-    rx145_cur."!cursor_pass"(rx145_pos, "hexints")
-    rx145_cur."!cursor_debug"("PASS  ", "hexints", " at pos=", rx145_pos)
+    rx145_cur."!cursor_pass"(rx145_pos, "octint")
+    rx145_cur."!cursor_debug"("PASS  ", "octint", " at pos=", rx145_pos)
     .return (rx145_cur)
-  rx145_fail:
+  rx145_restart:
 .annotate 'line', 33
+    rx145_cur."!cursor_debug"("NEXT ", "octint")
+  rx145_fail:
     (rx145_rep, rx145_pos, $I10, $P10) = rx145_cur."!mark_fail"(0)
     lt rx145_pos, -1, rx145_done
     eq rx145_pos, -1, rx145_fail
     jump $I10
   rx145_done:
     rx145_cur."!cursor_fail"()
-    rx145_cur."!cursor_debug"("FAIL  ", "hexints")
+    rx145_cur."!cursor_debug"("FAIL  ", "octint")
     .return (rx145_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__hexints"  :subid("52_1278500527.62277") :method
+.sub "!PREFIX__octint"  :subid("54_1279529214.68208") :method
 .annotate 'line', 33
     new $P147, "ResizablePMCArray"
     push $P147, ""
@@ -2335,7 +2513,7 @@
 
 
 .namespace ["HLL";"Grammar"]
-.sub "octint"  :subid("53_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "octints"  :subid("55_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
     .local string rx152_tgt
     .local int rx152_pos
@@ -2343,8 +2521,8 @@
     .local int rx152_eos
     .local int rx152_rep
     .local pmc rx152_cur
-    (rx152_cur, rx152_pos, rx152_tgt) = self."!cursor_start"()
-    rx152_cur."!cursor_debug"("START ", "octint")
+    (rx152_cur, rx152_pos, rx152_tgt, $I10) = self."!cursor_start"()
+    rx152_cur."!cursor_caparray"("octint")
     .lex unicode:"$\x{a2}", rx152_cur
     .local pmc match
     .lex "$/", match
@@ -2355,6 +2533,8 @@
     sub rx152_off, rx152_pos, 1
     substr rx152_tgt, rx152_tgt, rx152_off
   rx152_start:
+    eq $I10, 1, rx152_restart
+    rx152_cur."!cursor_debug"("START ", "octints")
     $I10 = self.'from'()
     ne $I10, -1, rxscan155_done
     goto rxscan155_scan
@@ -2367,57 +2547,63 @@
     set_addr $I10, rxscan155_loop
     rx152_cur."!mark_push"(0, rx152_pos, $I10)
   rxscan155_done:
-.annotate 'line', 54
+.annotate 'line', 55
   # rx rxquantr156 ** 1..*
-    set_addr $I159, rxquantr156_done
-    rx152_cur."!mark_push"(0, -1, $I159)
+    set_addr $I10, rxquantr156_done
+    rx152_cur."!mark_push"(0, -1, $I10)
   rxquantr156_loop:
-  # rx rxquantr157 ** 1..*
-    set_addr $I158, rxquantr157_done
-    rx152_cur."!mark_push"(0, -1, $I158)
-  rxquantr157_loop:
-  # rx enumcharlist negate=0 
-    ge rx152_pos, rx152_eos, rx152_fail
-    sub $I10, rx152_pos, rx152_off
-    substr $S10, rx152_tgt, $I10, 1
-    index $I11, "01234567", $S10
-    lt $I11, 0, rx152_fail
-    inc rx152_pos
-    (rx152_rep) = rx152_cur."!mark_commit"($I158)
-    rx152_cur."!mark_push"(rx152_rep, rx152_pos, $I158)
-    goto rxquantr157_loop
-  rxquantr157_done:
-    (rx152_rep) = rx152_cur."!mark_commit"($I159)
-    rx152_cur."!mark_push"(rx152_rep, rx152_pos, $I159)
-  # rx literal  "_"
+  # rx subrule "ws" subtype=method negate=
+    rx152_cur."!cursor_pos"(rx152_pos)
+    $P10 = rx152_cur."ws"()
+    unless $P10, rx152_fail
+    rx152_pos = $P10."pos"()
+  # rx subrule "octint" subtype=capture negate=
+    rx152_cur."!cursor_pos"(rx152_pos)
+    $P10 = rx152_cur."octint"()
+    unless $P10, rx152_fail
+    rx152_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("octint")
+    rx152_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx152_cur."!cursor_pos"(rx152_pos)
+    $P10 = rx152_cur."ws"()
+    unless $P10, rx152_fail
+    rx152_pos = $P10."pos"()
+    set_addr $I10, rxquantr156_done
+    (rx152_rep) = rx152_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr156_done
+    rx152_cur."!mark_push"(rx152_rep, rx152_pos, $I10)
+  # rx literal  ","
     add $I11, rx152_pos, 1
     gt $I11, rx152_eos, rx152_fail
     sub $I11, rx152_pos, rx152_off
     substr $S10, rx152_tgt, $I11, 1
-    ne $S10, "_", rx152_fail
+    ne $S10, ",", rx152_fail
     add rx152_pos, 1
     goto rxquantr156_loop
   rxquantr156_done:
   # rx pass
-    rx152_cur."!cursor_pass"(rx152_pos, "octint")
-    rx152_cur."!cursor_debug"("PASS  ", "octint", " at pos=", rx152_pos)
+    rx152_cur."!cursor_pass"(rx152_pos, "octints")
+    rx152_cur."!cursor_debug"("PASS  ", "octints", " at pos=", rx152_pos)
     .return (rx152_cur)
-  rx152_fail:
+  rx152_restart:
 .annotate 'line', 33
+    rx152_cur."!cursor_debug"("NEXT ", "octints")
+  rx152_fail:
     (rx152_rep, rx152_pos, $I10, $P10) = rx152_cur."!mark_fail"(0)
     lt rx152_pos, -1, rx152_done
     eq rx152_pos, -1, rx152_fail
     jump $I10
   rx152_done:
     rx152_cur."!cursor_fail"()
-    rx152_cur."!cursor_debug"("FAIL  ", "octint")
+    rx152_cur."!cursor_debug"("FAIL  ", "octints")
     .return (rx152_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__octint"  :subid("54_1278500527.62277") :method
+.sub "!PREFIX__octints"  :subid("56_1279529214.68208") :method
 .annotate 'line', 33
     new $P154, "ResizablePMCArray"
     push $P154, ""
@@ -2426,2477 +2612,2477 @@
 
 
 .namespace ["HLL";"Grammar"]
-.sub "octints"  :subid("55_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "binint"  :subid("57_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx161_tgt
-    .local int rx161_pos
-    .local int rx161_off
-    .local int rx161_eos
-    .local int rx161_rep
-    .local pmc rx161_cur
-    (rx161_cur, rx161_pos, rx161_tgt) = self."!cursor_start"()
-    rx161_cur."!cursor_debug"("START ", "octints")
-    rx161_cur."!cursor_caparray"("octint")
-    .lex unicode:"$\x{a2}", rx161_cur
+    .local string rx158_tgt
+    .local int rx158_pos
+    .local int rx158_off
+    .local int rx158_eos
+    .local int rx158_rep
+    .local pmc rx158_cur
+    (rx158_cur, rx158_pos, rx158_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx158_cur
     .local pmc match
     .lex "$/", match
-    length rx161_eos, rx161_tgt
-    gt rx161_pos, rx161_eos, rx161_done
-    set rx161_off, 0
-    lt rx161_pos, 2, rx161_start
-    sub rx161_off, rx161_pos, 1
-    substr rx161_tgt, rx161_tgt, rx161_off
-  rx161_start:
+    length rx158_eos, rx158_tgt
+    gt rx158_pos, rx158_eos, rx158_done
+    set rx158_off, 0
+    lt rx158_pos, 2, rx158_start
+    sub rx158_off, rx158_pos, 1
+    substr rx158_tgt, rx158_tgt, rx158_off
+  rx158_start:
+    eq $I10, 1, rx158_restart
+    rx158_cur."!cursor_debug"("START ", "binint")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan164_done
-    goto rxscan164_scan
-  rxscan164_loop:
-    ($P10) = rx161_cur."from"()
+    ne $I10, -1, rxscan161_done
+    goto rxscan161_scan
+  rxscan161_loop:
+    ($P10) = rx158_cur."from"()
     inc $P10
-    set rx161_pos, $P10
-    ge rx161_pos, rx161_eos, rxscan164_done
-  rxscan164_scan:
-    set_addr $I10, rxscan164_loop
-    rx161_cur."!mark_push"(0, rx161_pos, $I10)
-  rxscan164_done:
-.annotate 'line', 55
-  # rx rxquantr165 ** 1..*
-    set_addr $I166, rxquantr165_done
-    rx161_cur."!mark_push"(0, -1, $I166)
-  rxquantr165_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx161_cur."!cursor_pos"(rx161_pos)
-    $P10 = rx161_cur."ws"()
-    unless $P10, rx161_fail
-    rx161_pos = $P10."pos"()
-  # rx subrule "octint" subtype=capture negate=
-    rx161_cur."!cursor_pos"(rx161_pos)
-    $P10 = rx161_cur."octint"()
-    unless $P10, rx161_fail
-    rx161_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("octint")
-    rx161_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx161_cur."!cursor_pos"(rx161_pos)
-    $P10 = rx161_cur."ws"()
-    unless $P10, rx161_fail
-    rx161_pos = $P10."pos"()
-    (rx161_rep) = rx161_cur."!mark_commit"($I166)
-    rx161_cur."!mark_push"(rx161_rep, rx161_pos, $I166)
-  # rx literal  ","
-    add $I11, rx161_pos, 1
-    gt $I11, rx161_eos, rx161_fail
-    sub $I11, rx161_pos, rx161_off
-    substr $S10, rx161_tgt, $I11, 1
-    ne $S10, ",", rx161_fail
-    add rx161_pos, 1
-    goto rxquantr165_loop
-  rxquantr165_done:
-  # rx pass
-    rx161_cur."!cursor_pass"(rx161_pos, "octints")
-    rx161_cur."!cursor_debug"("PASS  ", "octints", " at pos=", rx161_pos)
-    .return (rx161_cur)
-  rx161_fail:
-.annotate 'line', 33
-    (rx161_rep, rx161_pos, $I10, $P10) = rx161_cur."!mark_fail"(0)
-    lt rx161_pos, -1, rx161_done
-    eq rx161_pos, -1, rx161_fail
-    jump $I10
-  rx161_done:
-    rx161_cur."!cursor_fail"()
-    rx161_cur."!cursor_debug"("FAIL  ", "octints")
-    .return (rx161_cur)
-    .return ()
-.end
-
-
-.namespace ["HLL";"Grammar"]
-.sub "!PREFIX__octints"  :subid("56_1278500527.62277") :method
-.annotate 'line', 33
-    new $P163, "ResizablePMCArray"
-    push $P163, ""
-    .return ($P163)
-.end
-
-
-.namespace ["HLL";"Grammar"]
-.sub "binint"  :subid("57_1278500527.62277") :method :outer("11_1278500527.62277")
-.annotate 'line', 33
-    .local string rx168_tgt
-    .local int rx168_pos
-    .local int rx168_off
-    .local int rx168_eos
-    .local int rx168_rep
-    .local pmc rx168_cur
-    (rx168_cur, rx168_pos, rx168_tgt) = self."!cursor_start"()
-    rx168_cur."!cursor_debug"("START ", "binint")
-    .lex unicode:"$\x{a2}", rx168_cur
-    .local pmc match
-    .lex "$/", match
-    length rx168_eos, rx168_tgt
-    gt rx168_pos, rx168_eos, rx168_done
-    set rx168_off, 0
-    lt rx168_pos, 2, rx168_start
-    sub rx168_off, rx168_pos, 1
-    substr rx168_tgt, rx168_tgt, rx168_off
-  rx168_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan171_done
-    goto rxscan171_scan
-  rxscan171_loop:
-    ($P10) = rx168_cur."from"()
-    inc $P10
-    set rx168_pos, $P10
-    ge rx168_pos, rx168_eos, rxscan171_done
-  rxscan171_scan:
-    set_addr $I10, rxscan171_loop
-    rx168_cur."!mark_push"(0, rx168_pos, $I10)
-  rxscan171_done:
+    set rx158_pos, $P10
+    ge rx158_pos, rx158_eos, rxscan161_done
+  rxscan161_scan:
+    set_addr $I10, rxscan161_loop
+    rx158_cur."!mark_push"(0, rx158_pos, $I10)
+  rxscan161_done:
 .annotate 'line', 57
-  # rx rxquantr172 ** 1..*
-    set_addr $I175, rxquantr172_done
-    rx168_cur."!mark_push"(0, -1, $I175)
-  rxquantr172_loop:
-  # rx rxquantr173 ** 1..*
-    set_addr $I174, rxquantr173_done
-    rx168_cur."!mark_push"(0, -1, $I174)
-  rxquantr173_loop:
+  # rx rxquantr162 ** 1..*
+    set_addr $I10, rxquantr162_done
+    rx158_cur."!mark_push"(0, -1, $I10)
+  rxquantr162_loop:
+  # rx rxquantr163 ** 1..*
+    set_addr $I10, rxquantr163_done
+    rx158_cur."!mark_push"(0, -1, $I10)
+  rxquantr163_loop:
   # rx enumcharlist negate=0 
-    ge rx168_pos, rx168_eos, rx168_fail
-    sub $I10, rx168_pos, rx168_off
-    substr $S10, rx168_tgt, $I10, 1
+    ge rx158_pos, rx158_eos, rx158_fail
+    sub $I10, rx158_pos, rx158_off
+    substr $S10, rx158_tgt, $I10, 1
     index $I11, "01", $S10
-    lt $I11, 0, rx168_fail
-    inc rx168_pos
-    (rx168_rep) = rx168_cur."!mark_commit"($I174)
-    rx168_cur."!mark_push"(rx168_rep, rx168_pos, $I174)
-    goto rxquantr173_loop
-  rxquantr173_done:
-    (rx168_rep) = rx168_cur."!mark_commit"($I175)
-    rx168_cur."!mark_push"(rx168_rep, rx168_pos, $I175)
+    lt $I11, 0, rx158_fail
+    inc rx158_pos
+    set_addr $I10, rxquantr163_done
+    (rx158_rep) = rx158_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr163_done
+    rx158_cur."!mark_push"(rx158_rep, rx158_pos, $I10)
+    goto rxquantr163_loop
+  rxquantr163_done:
+    set_addr $I10, rxquantr162_done
+    (rx158_rep) = rx158_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr162_done
+    rx158_cur."!mark_push"(rx158_rep, rx158_pos, $I10)
   # rx literal  "_"
-    add $I11, rx168_pos, 1
-    gt $I11, rx168_eos, rx168_fail
-    sub $I11, rx168_pos, rx168_off
-    substr $S10, rx168_tgt, $I11, 1
-    ne $S10, "_", rx168_fail
-    add rx168_pos, 1
-    goto rxquantr172_loop
-  rxquantr172_done:
+    add $I11, rx158_pos, 1
+    gt $I11, rx158_eos, rx158_fail
+    sub $I11, rx158_pos, rx158_off
+    substr $S10, rx158_tgt, $I11, 1
+    ne $S10, "_", rx158_fail
+    add rx158_pos, 1
+    goto rxquantr162_loop
+  rxquantr162_done:
   # rx pass
-    rx168_cur."!cursor_pass"(rx168_pos, "binint")
-    rx168_cur."!cursor_debug"("PASS  ", "binint", " at pos=", rx168_pos)
-    .return (rx168_cur)
-  rx168_fail:
-.annotate 'line', 33
-    (rx168_rep, rx168_pos, $I10, $P10) = rx168_cur."!mark_fail"(0)
-    lt rx168_pos, -1, rx168_done
-    eq rx168_pos, -1, rx168_fail
+    rx158_cur."!cursor_pass"(rx158_pos, "binint")
+    rx158_cur."!cursor_debug"("PASS  ", "binint", " at pos=", rx158_pos)
+    .return (rx158_cur)
+  rx158_restart:
+.annotate 'line', 33
+    rx158_cur."!cursor_debug"("NEXT ", "binint")
+  rx158_fail:
+    (rx158_rep, rx158_pos, $I10, $P10) = rx158_cur."!mark_fail"(0)
+    lt rx158_pos, -1, rx158_done
+    eq rx158_pos, -1, rx158_fail
     jump $I10
-  rx168_done:
-    rx168_cur."!cursor_fail"()
-    rx168_cur."!cursor_debug"("FAIL  ", "binint")
-    .return (rx168_cur)
+  rx158_done:
+    rx158_cur."!cursor_fail"()
+    rx158_cur."!cursor_debug"("FAIL  ", "binint")
+    .return (rx158_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__binint"  :subid("58_1278500527.62277") :method
+.sub "!PREFIX__binint"  :subid("58_1279529214.68208") :method
 .annotate 'line', 33
-    new $P170, "ResizablePMCArray"
-    push $P170, ""
-    .return ($P170)
+    new $P160, "ResizablePMCArray"
+    push $P160, ""
+    .return ($P160)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "binints"  :subid("59_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "binints"  :subid("59_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx177_tgt
-    .local int rx177_pos
-    .local int rx177_off
-    .local int rx177_eos
-    .local int rx177_rep
-    .local pmc rx177_cur
-    (rx177_cur, rx177_pos, rx177_tgt) = self."!cursor_start"()
-    rx177_cur."!cursor_debug"("START ", "binints")
-    rx177_cur."!cursor_caparray"("binint")
-    .lex unicode:"$\x{a2}", rx177_cur
+    .local string rx165_tgt
+    .local int rx165_pos
+    .local int rx165_off
+    .local int rx165_eos
+    .local int rx165_rep
+    .local pmc rx165_cur
+    (rx165_cur, rx165_pos, rx165_tgt, $I10) = self."!cursor_start"()
+    rx165_cur."!cursor_caparray"("binint")
+    .lex unicode:"$\x{a2}", rx165_cur
     .local pmc match
     .lex "$/", match
-    length rx177_eos, rx177_tgt
-    gt rx177_pos, rx177_eos, rx177_done
-    set rx177_off, 0
-    lt rx177_pos, 2, rx177_start
-    sub rx177_off, rx177_pos, 1
-    substr rx177_tgt, rx177_tgt, rx177_off
-  rx177_start:
+    length rx165_eos, rx165_tgt
+    gt rx165_pos, rx165_eos, rx165_done
+    set rx165_off, 0
+    lt rx165_pos, 2, rx165_start
+    sub rx165_off, rx165_pos, 1
+    substr rx165_tgt, rx165_tgt, rx165_off
+  rx165_start:
+    eq $I10, 1, rx165_restart
+    rx165_cur."!cursor_debug"("START ", "binints")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan180_done
-    goto rxscan180_scan
-  rxscan180_loop:
-    ($P10) = rx177_cur."from"()
+    ne $I10, -1, rxscan168_done
+    goto rxscan168_scan
+  rxscan168_loop:
+    ($P10) = rx165_cur."from"()
     inc $P10
-    set rx177_pos, $P10
-    ge rx177_pos, rx177_eos, rxscan180_done
-  rxscan180_scan:
-    set_addr $I10, rxscan180_loop
-    rx177_cur."!mark_push"(0, rx177_pos, $I10)
-  rxscan180_done:
+    set rx165_pos, $P10
+    ge rx165_pos, rx165_eos, rxscan168_done
+  rxscan168_scan:
+    set_addr $I10, rxscan168_loop
+    rx165_cur."!mark_push"(0, rx165_pos, $I10)
+  rxscan168_done:
 .annotate 'line', 58
-  # rx rxquantr181 ** 1..*
-    set_addr $I182, rxquantr181_done
-    rx177_cur."!mark_push"(0, -1, $I182)
-  rxquantr181_loop:
+  # rx rxquantr169 ** 1..*
+    set_addr $I10, rxquantr169_done
+    rx165_cur."!mark_push"(0, -1, $I10)
+  rxquantr169_loop:
   # rx subrule "ws" subtype=method negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."ws"()
-    unless $P10, rx177_fail
-    rx177_pos = $P10."pos"()
+    rx165_cur."!cursor_pos"(rx165_pos)
+    $P10 = rx165_cur."ws"()
+    unless $P10, rx165_fail
+    rx165_pos = $P10."pos"()
   # rx subrule "binint" subtype=capture negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."binint"()
-    unless $P10, rx177_fail
-    rx177_cur."!mark_push"(0, -1, 0, $P10)
+    rx165_cur."!cursor_pos"(rx165_pos)
+    $P10 = rx165_cur."binint"()
+    unless $P10, rx165_fail
+    rx165_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("binint")
-    rx177_pos = $P10."pos"()
+    rx165_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."ws"()
-    unless $P10, rx177_fail
-    rx177_pos = $P10."pos"()
-    (rx177_rep) = rx177_cur."!mark_commit"($I182)
-    rx177_cur."!mark_push"(rx177_rep, rx177_pos, $I182)
+    rx165_cur."!cursor_pos"(rx165_pos)
+    $P10 = rx165_cur."ws"()
+    unless $P10, rx165_fail
+    rx165_pos = $P10."pos"()
+    set_addr $I10, rxquantr169_done
+    (rx165_rep) = rx165_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr169_done
+    rx165_cur."!mark_push"(rx165_rep, rx165_pos, $I10)
   # rx literal  ","
-    add $I11, rx177_pos, 1
-    gt $I11, rx177_eos, rx177_fail
-    sub $I11, rx177_pos, rx177_off
-    substr $S10, rx177_tgt, $I11, 1
-    ne $S10, ",", rx177_fail
-    add rx177_pos, 1
-    goto rxquantr181_loop
-  rxquantr181_done:
+    add $I11, rx165_pos, 1
+    gt $I11, rx165_eos, rx165_fail
+    sub $I11, rx165_pos, rx165_off
+    substr $S10, rx165_tgt, $I11, 1
+    ne $S10, ",", rx165_fail
+    add rx165_pos, 1
+    goto rxquantr169_loop
+  rxquantr169_done:
   # rx pass
-    rx177_cur."!cursor_pass"(rx177_pos, "binints")
-    rx177_cur."!cursor_debug"("PASS  ", "binints", " at pos=", rx177_pos)
-    .return (rx177_cur)
-  rx177_fail:
-.annotate 'line', 33
-    (rx177_rep, rx177_pos, $I10, $P10) = rx177_cur."!mark_fail"(0)
-    lt rx177_pos, -1, rx177_done
-    eq rx177_pos, -1, rx177_fail
+    rx165_cur."!cursor_pass"(rx165_pos, "binints")
+    rx165_cur."!cursor_debug"("PASS  ", "binints", " at pos=", rx165_pos)
+    .return (rx165_cur)
+  rx165_restart:
+.annotate 'line', 33
+    rx165_cur."!cursor_debug"("NEXT ", "binints")
+  rx165_fail:
+    (rx165_rep, rx165_pos, $I10, $P10) = rx165_cur."!mark_fail"(0)
+    lt rx165_pos, -1, rx165_done
+    eq rx165_pos, -1, rx165_fail
     jump $I10
-  rx177_done:
-    rx177_cur."!cursor_fail"()
-    rx177_cur."!cursor_debug"("FAIL  ", "binints")
-    .return (rx177_cur)
+  rx165_done:
+    rx165_cur."!cursor_fail"()
+    rx165_cur."!cursor_debug"("FAIL  ", "binints")
+    .return (rx165_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__binints"  :subid("60_1278500527.62277") :method
+.sub "!PREFIX__binints"  :subid("60_1279529214.68208") :method
 .annotate 'line', 33
-    new $P179, "ResizablePMCArray"
-    push $P179, ""
-    .return ($P179)
+    new $P167, "ResizablePMCArray"
+    push $P167, ""
+    .return ($P167)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "integer"  :subid("61_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "integer"  :subid("61_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx184_tgt
-    .local int rx184_pos
-    .local int rx184_off
-    .local int rx184_eos
-    .local int rx184_rep
-    .local pmc rx184_cur
-    (rx184_cur, rx184_pos, rx184_tgt) = self."!cursor_start"()
-    rx184_cur."!cursor_debug"("START ", "integer")
-    .lex unicode:"$\x{a2}", rx184_cur
+    .local string rx171_tgt
+    .local int rx171_pos
+    .local int rx171_off
+    .local int rx171_eos
+    .local int rx171_rep
+    .local pmc rx171_cur
+    (rx171_cur, rx171_pos, rx171_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx171_cur
     .local pmc match
     .lex "$/", match
-    length rx184_eos, rx184_tgt
-    gt rx184_pos, rx184_eos, rx184_done
-    set rx184_off, 0
-    lt rx184_pos, 2, rx184_start
-    sub rx184_off, rx184_pos, 1
-    substr rx184_tgt, rx184_tgt, rx184_off
-  rx184_start:
+    length rx171_eos, rx171_tgt
+    gt rx171_pos, rx171_eos, rx171_done
+    set rx171_off, 0
+    lt rx171_pos, 2, rx171_start
+    sub rx171_off, rx171_pos, 1
+    substr rx171_tgt, rx171_tgt, rx171_off
+  rx171_start:
+    eq $I10, 1, rx171_restart
+    rx171_cur."!cursor_debug"("START ", "integer")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan192_done
-    goto rxscan192_scan
-  rxscan192_loop:
-    ($P10) = rx184_cur."from"()
+    ne $I10, -1, rxscan179_done
+    goto rxscan179_scan
+  rxscan179_loop:
+    ($P10) = rx171_cur."from"()
     inc $P10
-    set rx184_pos, $P10
-    ge rx184_pos, rx184_eos, rxscan192_done
-  rxscan192_scan:
-    set_addr $I10, rxscan192_loop
-    rx184_cur."!mark_push"(0, rx184_pos, $I10)
-  rxscan192_done:
-  alt193_0:
+    set rx171_pos, $P10
+    ge rx171_pos, rx171_eos, rxscan179_done
+  rxscan179_scan:
+    set_addr $I10, rxscan179_loop
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+  rxscan179_done:
+  alt180_0:
 .annotate 'line', 61
-    set_addr $I10, alt193_1
-    rx184_cur."!mark_push"(0, rx184_pos, $I10)
+    set_addr $I10, alt180_1
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
 .annotate 'line', 62
   # rx literal  "0"
-    add $I11, rx184_pos, 1
-    gt $I11, rx184_eos, rx184_fail
-    sub $I11, rx184_pos, rx184_off
-    substr $S10, rx184_tgt, $I11, 1
-    ne $S10, "0", rx184_fail
-    add rx184_pos, 1
-  alt194_0:
-    set_addr $I10, alt194_1
-    rx184_cur."!mark_push"(0, rx184_pos, $I10)
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "0", rx171_fail
+    add rx171_pos, 1
+  alt181_0:
+    set_addr $I10, alt181_1
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
   # rx literal  "b"
-    add $I11, rx184_pos, 1
-    gt $I11, rx184_eos, rx184_fail
-    sub $I11, rx184_pos, rx184_off
-    substr $S10, rx184_tgt, $I11, 1
-    ne $S10, "b", rx184_fail
-    add rx184_pos, 1
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "b", rx171_fail
+    add rx171_pos, 1
   # rx subrule "binint" subtype=capture negate=
-    rx184_cur."!cursor_pos"(rx184_pos)
-    $P10 = rx184_cur."binint"()
-    unless $P10, rx184_fail
-    rx184_cur."!mark_push"(0, -1, 0, $P10)
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."binint"()
+    unless $P10, rx171_fail
+    rx171_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("VALUE=binint")
-    rx184_pos = $P10."pos"()
-    goto alt194_end
-  alt194_1:
-    set_addr $I10, alt194_2
-    rx184_cur."!mark_push"(0, rx184_pos, $I10)
+    rx171_pos = $P10."pos"()
+    goto alt181_end
+  alt181_1:
+    set_addr $I10, alt181_2
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
 .annotate 'line', 63
   # rx literal  "o"
-    add $I11, rx184_pos, 1
-    gt $I11, rx184_eos, rx184_fail
-    sub $I11, rx184_pos, rx184_off
-    substr $S10, rx184_tgt, $I11, 1
-    ne $S10, "o", rx184_fail
-    add rx184_pos, 1
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "o", rx171_fail
+    add rx171_pos, 1
   # rx subrule "octint" subtype=capture negate=
-    rx184_cur."!cursor_pos"(rx184_pos)
-    $P10 = rx184_cur."octint"()
-    unless $P10, rx184_fail
-    rx184_cur."!mark_push"(0, -1, 0, $P10)
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."octint"()
+    unless $P10, rx171_fail
+    rx171_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("VALUE=octint")
-    rx184_pos = $P10."pos"()
-    goto alt194_end
-  alt194_2:
-    set_addr $I10, alt194_3
-    rx184_cur."!mark_push"(0, rx184_pos, $I10)
+    rx171_pos = $P10."pos"()
+    goto alt181_end
+  alt181_2:
+    set_addr $I10, alt181_3
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
 .annotate 'line', 64
   # rx literal  "x"
-    add $I11, rx184_pos, 1
-    gt $I11, rx184_eos, rx184_fail
-    sub $I11, rx184_pos, rx184_off
-    substr $S10, rx184_tgt, $I11, 1
-    ne $S10, "x", rx184_fail
-    add rx184_pos, 1
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "x", rx171_fail
+    add rx171_pos, 1
   # rx subrule "hexint" subtype=capture negate=
-    rx184_cur."!cursor_pos"(rx184_pos)
-    $P10 = rx184_cur."hexint"()
-    unless $P10, rx184_fail
-    rx184_cur."!mark_push"(0, -1, 0, $P10)
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."hexint"()
+    unless $P10, rx171_fail
+    rx171_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("VALUE=hexint")
-    rx184_pos = $P10."pos"()
-    goto alt194_end
-  alt194_3:
+    rx171_pos = $P10."pos"()
+    goto alt181_end
+  alt181_3:
 .annotate 'line', 65
   # rx literal  "d"
-    add $I11, rx184_pos, 1
-    gt $I11, rx184_eos, rx184_fail
-    sub $I11, rx184_pos, rx184_off
-    substr $S10, rx184_tgt, $I11, 1
-    ne $S10, "d", rx184_fail
-    add rx184_pos, 1
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "d", rx171_fail
+    add rx171_pos, 1
   # rx subrule "decint" subtype=capture negate=
-    rx184_cur."!cursor_pos"(rx184_pos)
-    $P10 = rx184_cur."decint"()
-    unless $P10, rx184_fail
-    rx184_cur."!mark_push"(0, -1, 0, $P10)
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."decint"()
+    unless $P10, rx171_fail
+    rx171_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("VALUE=decint")
-    rx184_pos = $P10."pos"()
-  alt194_end:
+    rx171_pos = $P10."pos"()
+  alt181_end:
 .annotate 'line', 62
-    goto alt193_end
-  alt193_1:
+    goto alt180_end
+  alt180_1:
 .annotate 'line', 67
   # rx subrule "decint" subtype=capture negate=
-    rx184_cur."!cursor_pos"(rx184_pos)
-    $P10 = rx184_cur."decint"()
-    unless $P10, rx184_fail
-    rx184_cur."!mark_push"(0, -1, 0, $P10)
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."decint"()
+    unless $P10, rx171_fail
+    rx171_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("VALUE=decint")
-    rx184_pos = $P10."pos"()
-  alt193_end:
+    rx171_pos = $P10."pos"()
+  alt180_end:
 .annotate 'line', 60
   # rx pass
-    rx184_cur."!cursor_pass"(rx184_pos, "integer")
-    rx184_cur."!cursor_debug"("PASS  ", "integer", " at pos=", rx184_pos)
-    .return (rx184_cur)
-  rx184_fail:
-.annotate 'line', 33
-    (rx184_rep, rx184_pos, $I10, $P10) = rx184_cur."!mark_fail"(0)
-    lt rx184_pos, -1, rx184_done
-    eq rx184_pos, -1, rx184_fail
+    rx171_cur."!cursor_pass"(rx171_pos, "integer")
+    rx171_cur."!cursor_debug"("PASS  ", "integer", " at pos=", rx171_pos)
+    .return (rx171_cur)
+  rx171_restart:
+.annotate 'line', 33
+    rx171_cur."!cursor_debug"("NEXT ", "integer")
+  rx171_fail:
+    (rx171_rep, rx171_pos, $I10, $P10) = rx171_cur."!mark_fail"(0)
+    lt rx171_pos, -1, rx171_done
+    eq rx171_pos, -1, rx171_fail
     jump $I10
-  rx184_done:
-    rx184_cur."!cursor_fail"()
-    rx184_cur."!cursor_debug"("FAIL  ", "integer")
-    .return (rx184_cur)
+  rx171_done:
+    rx171_cur."!cursor_fail"()
+    rx171_cur."!cursor_debug"("FAIL  ", "integer")
+    .return (rx171_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__integer"  :subid("62_1278500527.62277") :method
+.sub "!PREFIX__integer"  :subid("62_1279529214.68208") :method
 .annotate 'line', 33
-    $P186 = self."!PREFIX__!subrule"("decint", "")
-    $P187 = self."!PREFIX__!subrule"("decint", "0d")
-    $P188 = self."!PREFIX__!subrule"("hexint", "0x")
-    $P189 = self."!PREFIX__!subrule"("octint", "0o")
-    $P190 = self."!PREFIX__!subrule"("binint", "0b")
-    new $P191, "ResizablePMCArray"
-    push $P191, $P186
-    push $P191, $P187
-    push $P191, $P188
-    push $P191, $P189
-    push $P191, $P190
-    .return ($P191)
+    $P173 = self."!PREFIX__!subrule"("decint", "")
+    $P174 = self."!PREFIX__!subrule"("decint", "0d")
+    $P175 = self."!PREFIX__!subrule"("hexint", "0x")
+    $P176 = self."!PREFIX__!subrule"("octint", "0o")
+    $P177 = self."!PREFIX__!subrule"("binint", "0b")
+    new $P178, "ResizablePMCArray"
+    push $P178, $P173
+    push $P178, $P174
+    push $P178, $P175
+    push $P178, $P176
+    push $P178, $P177
+    .return ($P178)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "dec_number"  :subid("63_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "dec_number"  :subid("63_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx196_tgt
-    .local int rx196_pos
-    .local int rx196_off
-    .local int rx196_eos
-    .local int rx196_rep
-    .local pmc rx196_cur
-    (rx196_cur, rx196_pos, rx196_tgt) = self."!cursor_start"()
-    rx196_cur."!cursor_debug"("START ", "dec_number")
-    rx196_cur."!cursor_caparray"("escale")
-    .lex unicode:"$\x{a2}", rx196_cur
+    .local string rx183_tgt
+    .local int rx183_pos
+    .local int rx183_off
+    .local int rx183_eos
+    .local int rx183_rep
+    .local pmc rx183_cur
+    (rx183_cur, rx183_pos, rx183_tgt, $I10) = self."!cursor_start"()
+    rx183_cur."!cursor_caparray"("escale")
+    .lex unicode:"$\x{a2}", rx183_cur
     .local pmc match
     .lex "$/", match
-    length rx196_eos, rx196_tgt
-    gt rx196_pos, rx196_eos, rx196_done
-    set rx196_off, 0
-    lt rx196_pos, 2, rx196_start
-    sub rx196_off, rx196_pos, 1
-    substr rx196_tgt, rx196_tgt, rx196_off
-  rx196_start:
+    length rx183_eos, rx183_tgt
+    gt rx183_pos, rx183_eos, rx183_done
+    set rx183_off, 0
+    lt rx183_pos, 2, rx183_start
+    sub rx183_off, rx183_pos, 1
+    substr rx183_tgt, rx183_tgt, rx183_off
+  rx183_start:
+    eq $I10, 1, rx183_restart
+    rx183_cur."!cursor_debug"("START ", "dec_number")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan199_done
-    goto rxscan199_scan
-  rxscan199_loop:
-    ($P10) = rx196_cur."from"()
+    ne $I10, -1, rxscan186_done
+    goto rxscan186_scan
+  rxscan186_loop:
+    ($P10) = rx183_cur."from"()
     inc $P10
-    set rx196_pos, $P10
-    ge rx196_pos, rx196_eos, rxscan199_done
-  rxscan199_scan:
-    set_addr $I10, rxscan199_loop
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
-  rxscan199_done:
-  alt200_0:
+    set rx183_pos, $P10
+    ge rx183_pos, rx183_eos, rxscan186_done
+  rxscan186_scan:
+    set_addr $I10, rxscan186_loop
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
+  rxscan186_done:
+  alt187_0:
 .annotate 'line', 71
-    set_addr $I10, alt200_1
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+    set_addr $I10, alt187_1
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
 .annotate 'line', 72
   # rx subcapture "coeff"
-    set_addr $I10, rxcap_201_fail
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+    set_addr $I10, rxcap_188_fail
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
   # rx literal  "."
-    add $I11, rx196_pos, 1
-    gt $I11, rx196_eos, rx196_fail
-    sub $I11, rx196_pos, rx196_off
-    substr $S10, rx196_tgt, $I11, 1
-    ne $S10, ".", rx196_fail
-    add rx196_pos, 1
+    add $I11, rx183_pos, 1
+    gt $I11, rx183_eos, rx183_fail
+    sub $I11, rx183_pos, rx183_off
+    substr $S10, rx183_tgt, $I11, 1
+    ne $S10, ".", rx183_fail
+    add rx183_pos, 1
   # rx charclass_q d r 1..-1
-    sub $I10, rx196_pos, rx196_off
-    find_not_cclass $I11, 8, rx196_tgt, $I10, rx196_eos
+    sub $I10, rx183_pos, rx183_off
+    find_not_cclass $I11, 8, rx183_tgt, $I10, rx183_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx196_fail
-    add rx196_pos, rx196_off, $I11
-    set_addr $I10, rxcap_201_fail
-    ($I12, $I11) = rx196_cur."!mark_peek"($I10)
-    rx196_cur."!cursor_pos"($I11)
-    ($P10) = rx196_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx196_pos, "")
-    rx196_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx183_fail
+    add rx183_pos, rx183_off, $I11
+    set_addr $I10, rxcap_188_fail
+    ($I12, $I11) = rx183_cur."!mark_peek"($I10)
+    rx183_cur."!cursor_pos"($I11)
+    ($P10) = rx183_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx183_pos, "")
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("coeff")
-    goto rxcap_201_done
-  rxcap_201_fail:
-    goto rx196_fail
-  rxcap_201_done:
-  # rx rxquantr202 ** 0..1
-    set_addr $I203, rxquantr202_done
-    rx196_cur."!mark_push"(0, rx196_pos, $I203)
-  rxquantr202_loop:
+    goto rxcap_188_done
+  rxcap_188_fail:
+    goto rx183_fail
+  rxcap_188_done:
+  # rx rxquantr189 ** 0..1
+    set_addr $I10, rxquantr189_done
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
+  rxquantr189_loop:
   # rx subrule "escale" subtype=capture negate=
-    rx196_cur."!cursor_pos"(rx196_pos)
-    $P10 = rx196_cur."escale"()
-    unless $P10, rx196_fail
-    rx196_cur."!mark_push"(0, -1, 0, $P10)
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."escale"()
+    unless $P10, rx183_fail
+    goto rxsubrule190_pass
+  rxsubrule190_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx183_fail
+  rxsubrule190_pass:
+    set_addr $I10, rxsubrule190_back
+    rx183_cur."!mark_push"(0, rx183_pos, $I10, $P10)
     $P10."!cursor_names"("escale")
-    rx196_pos = $P10."pos"()
-    (rx196_rep) = rx196_cur."!mark_commit"($I203)
-  rxquantr202_done:
-    goto alt200_end
-  alt200_1:
-    set_addr $I10, alt200_2
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+    rx183_pos = $P10."pos"()
+    set_addr $I10, rxquantr189_done
+    (rx183_rep) = rx183_cur."!mark_commit"($I10)
+  rxquantr189_done:
+    goto alt187_end
+  alt187_1:
+    set_addr $I10, alt187_2
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
 .annotate 'line', 73
   # rx subcapture "coeff"
-    set_addr $I10, rxcap_204_fail
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+    set_addr $I10, rxcap_191_fail
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
   # rx charclass_q d r 1..-1
-    sub $I10, rx196_pos, rx196_off
-    find_not_cclass $I11, 8, rx196_tgt, $I10, rx196_eos
+    sub $I10, rx183_pos, rx183_off
+    find_not_cclass $I11, 8, rx183_tgt, $I10, rx183_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx196_fail
-    add rx196_pos, rx196_off, $I11
+    lt $I11, $I12, rx183_fail
+    add rx183_pos, rx183_off, $I11
   # rx literal  "."
-    add $I11, rx196_pos, 1
-    gt $I11, rx196_eos, rx196_fail
-    sub $I11, rx196_pos, rx196_off
-    substr $S10, rx196_tgt, $I11, 1
-    ne $S10, ".", rx196_fail
-    add rx196_pos, 1
+    add $I11, rx183_pos, 1
+    gt $I11, rx183_eos, rx183_fail
+    sub $I11, rx183_pos, rx183_off
+    substr $S10, rx183_tgt, $I11, 1
+    ne $S10, ".", rx183_fail
+    add rx183_pos, 1
   # rx charclass_q d r 1..-1
-    sub $I10, rx196_pos, rx196_off
-    find_not_cclass $I11, 8, rx196_tgt, $I10, rx196_eos
+    sub $I10, rx183_pos, rx183_off
+    find_not_cclass $I11, 8, rx183_tgt, $I10, rx183_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx196_fail
-    add rx196_pos, rx196_off, $I11
-    set_addr $I10, rxcap_204_fail
-    ($I12, $I11) = rx196_cur."!mark_peek"($I10)
-    rx196_cur."!cursor_pos"($I11)
-    ($P10) = rx196_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx196_pos, "")
-    rx196_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx183_fail
+    add rx183_pos, rx183_off, $I11
+    set_addr $I10, rxcap_191_fail
+    ($I12, $I11) = rx183_cur."!mark_peek"($I10)
+    rx183_cur."!cursor_pos"($I11)
+    ($P10) = rx183_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx183_pos, "")
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("coeff")
-    goto rxcap_204_done
-  rxcap_204_fail:
-    goto rx196_fail
-  rxcap_204_done:
-  # rx rxquantr205 ** 0..1
-    set_addr $I206, rxquantr205_done
-    rx196_cur."!mark_push"(0, rx196_pos, $I206)
-  rxquantr205_loop:
+    goto rxcap_191_done
+  rxcap_191_fail:
+    goto rx183_fail
+  rxcap_191_done:
+  # rx rxquantr192 ** 0..1
+    set_addr $I10, rxquantr192_done
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
+  rxquantr192_loop:
   # rx subrule "escale" subtype=capture negate=
-    rx196_cur."!cursor_pos"(rx196_pos)
-    $P10 = rx196_cur."escale"()
-    unless $P10, rx196_fail
-    rx196_cur."!mark_push"(0, -1, 0, $P10)
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."escale"()
+    unless $P10, rx183_fail
+    goto rxsubrule193_pass
+  rxsubrule193_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx183_fail
+  rxsubrule193_pass:
+    set_addr $I10, rxsubrule193_back
+    rx183_cur."!mark_push"(0, rx183_pos, $I10, $P10)
     $P10."!cursor_names"("escale")
-    rx196_pos = $P10."pos"()
-    (rx196_rep) = rx196_cur."!mark_commit"($I206)
-  rxquantr205_done:
-    goto alt200_end
-  alt200_2:
+    rx183_pos = $P10."pos"()
+    set_addr $I10, rxquantr192_done
+    (rx183_rep) = rx183_cur."!mark_commit"($I10)
+  rxquantr192_done:
+    goto alt187_end
+  alt187_2:
 .annotate 'line', 74
   # rx subcapture "coeff"
-    set_addr $I10, rxcap_207_fail
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+    set_addr $I10, rxcap_194_fail
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
   # rx charclass_q d r 1..-1
-    sub $I10, rx196_pos, rx196_off
-    find_not_cclass $I11, 8, rx196_tgt, $I10, rx196_eos
+    sub $I10, rx183_pos, rx183_off
+    find_not_cclass $I11, 8, rx183_tgt, $I10, rx183_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx196_fail
-    add rx196_pos, rx196_off, $I11
-    set_addr $I10, rxcap_207_fail
-    ($I12, $I11) = rx196_cur."!mark_peek"($I10)
-    rx196_cur."!cursor_pos"($I11)
-    ($P10) = rx196_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx196_pos, "")
-    rx196_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx183_fail
+    add rx183_pos, rx183_off, $I11
+    set_addr $I10, rxcap_194_fail
+    ($I12, $I11) = rx183_cur."!mark_peek"($I10)
+    rx183_cur."!cursor_pos"($I11)
+    ($P10) = rx183_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx183_pos, "")
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("coeff")
-    goto rxcap_207_done
-  rxcap_207_fail:
-    goto rx196_fail
-  rxcap_207_done:
+    goto rxcap_194_done
+  rxcap_194_fail:
+    goto rx183_fail
+  rxcap_194_done:
   # rx subrule "escale" subtype=capture negate=
-    rx196_cur."!cursor_pos"(rx196_pos)
-    $P10 = rx196_cur."escale"()
-    unless $P10, rx196_fail
-    rx196_cur."!mark_push"(0, -1, 0, $P10)
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."escale"()
+    unless $P10, rx183_fail
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("escale")
-    rx196_pos = $P10."pos"()
-  alt200_end:
+    rx183_pos = $P10."pos"()
+  alt187_end:
 .annotate 'line', 71
   # rx pass
-    rx196_cur."!cursor_pass"(rx196_pos, "dec_number")
-    rx196_cur."!cursor_debug"("PASS  ", "dec_number", " at pos=", rx196_pos)
-    .return (rx196_cur)
-  rx196_fail:
-.annotate 'line', 33
-    (rx196_rep, rx196_pos, $I10, $P10) = rx196_cur."!mark_fail"(0)
-    lt rx196_pos, -1, rx196_done
-    eq rx196_pos, -1, rx196_fail
+    rx183_cur."!cursor_pass"(rx183_pos, "dec_number")
+    rx183_cur."!cursor_debug"("PASS  ", "dec_number", " at pos=", rx183_pos)
+    .return (rx183_cur)
+  rx183_restart:
+.annotate 'line', 33
+    rx183_cur."!cursor_debug"("NEXT ", "dec_number")
+  rx183_fail:
+    (rx183_rep, rx183_pos, $I10, $P10) = rx183_cur."!mark_fail"(0)
+    lt rx183_pos, -1, rx183_done
+    eq rx183_pos, -1, rx183_fail
     jump $I10
-  rx196_done:
-    rx196_cur."!cursor_fail"()
-    rx196_cur."!cursor_debug"("FAIL  ", "dec_number")
-    .return (rx196_cur)
+  rx183_done:
+    rx183_cur."!cursor_fail"()
+    rx183_cur."!cursor_debug"("FAIL  ", "dec_number")
+    .return (rx183_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__dec_number"  :subid("64_1278500527.62277") :method
+.sub "!PREFIX__dec_number"  :subid("64_1279529214.68208") :method
 .annotate 'line', 33
-    new $P198, "ResizablePMCArray"
-    push $P198, ""
-    push $P198, ""
-    push $P198, "."
-    .return ($P198)
+    new $P185, "ResizablePMCArray"
+    push $P185, ""
+    push $P185, ""
+    push $P185, "."
+    .return ($P185)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "escale"  :subid("65_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "escale"  :subid("65_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx209_tgt
-    .local int rx209_pos
-    .local int rx209_off
-    .local int rx209_eos
-    .local int rx209_rep
-    .local pmc rx209_cur
-    (rx209_cur, rx209_pos, rx209_tgt) = self."!cursor_start"()
-    rx209_cur."!cursor_debug"("START ", "escale")
-    .lex unicode:"$\x{a2}", rx209_cur
+    .local string rx196_tgt
+    .local int rx196_pos
+    .local int rx196_off
+    .local int rx196_eos
+    .local int rx196_rep
+    .local pmc rx196_cur
+    (rx196_cur, rx196_pos, rx196_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx196_cur
     .local pmc match
     .lex "$/", match
-    length rx209_eos, rx209_tgt
-    gt rx209_pos, rx209_eos, rx209_done
-    set rx209_off, 0
-    lt rx209_pos, 2, rx209_start
-    sub rx209_off, rx209_pos, 1
-    substr rx209_tgt, rx209_tgt, rx209_off
-  rx209_start:
+    length rx196_eos, rx196_tgt
+    gt rx196_pos, rx196_eos, rx196_done
+    set rx196_off, 0
+    lt rx196_pos, 2, rx196_start
+    sub rx196_off, rx196_pos, 1
+    substr rx196_tgt, rx196_tgt, rx196_off
+  rx196_start:
+    eq $I10, 1, rx196_restart
+    rx196_cur."!cursor_debug"("START ", "escale")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan212_done
-    goto rxscan212_scan
-  rxscan212_loop:
-    ($P10) = rx209_cur."from"()
+    ne $I10, -1, rxscan199_done
+    goto rxscan199_scan
+  rxscan199_loop:
+    ($P10) = rx196_cur."from"()
     inc $P10
-    set rx209_pos, $P10
-    ge rx209_pos, rx209_eos, rxscan212_done
-  rxscan212_scan:
-    set_addr $I10, rxscan212_loop
-    rx209_cur."!mark_push"(0, rx209_pos, $I10)
-  rxscan212_done:
+    set rx196_pos, $P10
+    ge rx196_pos, rx196_eos, rxscan199_done
+  rxscan199_scan:
+    set_addr $I10, rxscan199_loop
+    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+  rxscan199_done:
 .annotate 'line', 77
   # rx enumcharlist negate=0 
-    ge rx209_pos, rx209_eos, rx209_fail
-    sub $I10, rx209_pos, rx209_off
-    substr $S10, rx209_tgt, $I10, 1
+    ge rx196_pos, rx196_eos, rx196_fail
+    sub $I10, rx196_pos, rx196_off
+    substr $S10, rx196_tgt, $I10, 1
     index $I11, "Ee", $S10
-    lt $I11, 0, rx209_fail
-    inc rx209_pos
-  # rx rxquantr213 ** 0..1
-    set_addr $I214, rxquantr213_done
-    rx209_cur."!mark_push"(0, rx209_pos, $I214)
-  rxquantr213_loop:
+    lt $I11, 0, rx196_fail
+    inc rx196_pos
+  # rx rxquantr200 ** 0..1
+    set_addr $I10, rxquantr200_done
+    rx196_cur."!mark_push"(0, rx196_pos, $I10)
+  rxquantr200_loop:
   # rx enumcharlist negate=0 
-    ge rx209_pos, rx209_eos, rx209_fail
-    sub $I10, rx209_pos, rx209_off
-    substr $S10, rx209_tgt, $I10, 1
+    ge rx196_pos, rx196_eos, rx196_fail
+    sub $I10, rx196_pos, rx196_off
+    substr $S10, rx196_tgt, $I10, 1
     index $I11, "+-", $S10
-    lt $I11, 0, rx209_fail
-    inc rx209_pos
-    (rx209_rep) = rx209_cur."!mark_commit"($I214)
-  rxquantr213_done:
+    lt $I11, 0, rx196_fail
+    inc rx196_pos
+    set_addr $I10, rxquantr200_done
+    (rx196_rep) = rx196_cur."!mark_commit"($I10)
+  rxquantr200_done:
   # rx charclass_q d r 1..-1
-    sub $I10, rx209_pos, rx209_off
-    find_not_cclass $I11, 8, rx209_tgt, $I10, rx209_eos
+    sub $I10, rx196_pos, rx196_off
+    find_not_cclass $I11, 8, rx196_tgt, $I10, rx196_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx209_fail
-    add rx209_pos, rx209_off, $I11
+    lt $I11, $I12, rx196_fail
+    add rx196_pos, rx196_off, $I11
   # rx pass
-    rx209_cur."!cursor_pass"(rx209_pos, "escale")
-    rx209_cur."!cursor_debug"("PASS  ", "escale", " at pos=", rx209_pos)
-    .return (rx209_cur)
-  rx209_fail:
-.annotate 'line', 33
-    (rx209_rep, rx209_pos, $I10, $P10) = rx209_cur."!mark_fail"(0)
-    lt rx209_pos, -1, rx209_done
-    eq rx209_pos, -1, rx209_fail
+    rx196_cur."!cursor_pass"(rx196_pos, "escale")
+    rx196_cur."!cursor_debug"("PASS  ", "escale", " at pos=", rx196_pos)
+    .return (rx196_cur)
+  rx196_restart:
+.annotate 'line', 33
+    rx196_cur."!cursor_debug"("NEXT ", "escale")
+  rx196_fail:
+    (rx196_rep, rx196_pos, $I10, $P10) = rx196_cur."!mark_fail"(0)
+    lt rx196_pos, -1, rx196_done
+    eq rx196_pos, -1, rx196_fail
     jump $I10
-  rx209_done:
-    rx209_cur."!cursor_fail"()
-    rx209_cur."!cursor_debug"("FAIL  ", "escale")
-    .return (rx209_cur)
+  rx196_done:
+    rx196_cur."!cursor_fail"()
+    rx196_cur."!cursor_debug"("FAIL  ", "escale")
+    .return (rx196_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__escale"  :subid("66_1278500527.62277") :method
+.sub "!PREFIX__escale"  :subid("66_1279529214.68208") :method
 .annotate 'line', 33
-    new $P211, "ResizablePMCArray"
-    push $P211, "e"
-    push $P211, "E"
-    .return ($P211)
+    new $P198, "ResizablePMCArray"
+    push $P198, "e"
+    push $P198, "E"
+    .return ($P198)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape"  :subid("67_1278500527.62277") :method
+.sub "quote_escape"  :subid("67_1279529214.68208") :method
 .annotate 'line', 79
-    $P216 = self."!protoregex"("quote_escape")
-    .return ($P216)
+    $P202 = self."!protoregex"("quote_escape")
+    .return ($P202)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape"  :subid("68_1278500527.62277") :method
+.sub "!PREFIX__quote_escape"  :subid("68_1279529214.68208") :method
 .annotate 'line', 79
-    $P218 = self."!PREFIX__!protoregex"("quote_escape")
-    .return ($P218)
+    $P204 = self."!PREFIX__!protoregex"("quote_escape")
+    .return ($P204)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<backslash>"  :subid("69_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<backslash>"  :subid("69_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx220_tgt
-    .local int rx220_pos
-    .local int rx220_off
-    .local int rx220_eos
-    .local int rx220_rep
-    .local pmc rx220_cur
-    (rx220_cur, rx220_pos, rx220_tgt) = self."!cursor_start"()
-    rx220_cur."!cursor_debug"("START ", "quote_escape:sym<backslash>")
-    .lex unicode:"$\x{a2}", rx220_cur
+    .local string rx206_tgt
+    .local int rx206_pos
+    .local int rx206_off
+    .local int rx206_eos
+    .local int rx206_rep
+    .local pmc rx206_cur
+    (rx206_cur, rx206_pos, rx206_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx206_cur
     .local pmc match
     .lex "$/", match
-    length rx220_eos, rx220_tgt
-    gt rx220_pos, rx220_eos, rx220_done
-    set rx220_off, 0
-    lt rx220_pos, 2, rx220_start
-    sub rx220_off, rx220_pos, 1
-    substr rx220_tgt, rx220_tgt, rx220_off
-  rx220_start:
+    length rx206_eos, rx206_tgt
+    gt rx206_pos, rx206_eos, rx206_done
+    set rx206_off, 0
+    lt rx206_pos, 2, rx206_start
+    sub rx206_off, rx206_pos, 1
+    substr rx206_tgt, rx206_tgt, rx206_off
+  rx206_start:
+    eq $I10, 1, rx206_restart
+    rx206_cur."!cursor_debug"("START ", "quote_escape:sym<backslash>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan223_done
-    goto rxscan223_scan
-  rxscan223_loop:
-    ($P10) = rx220_cur."from"()
+    ne $I10, -1, rxscan209_done
+    goto rxscan209_scan
+  rxscan209_loop:
+    ($P10) = rx206_cur."from"()
     inc $P10
-    set rx220_pos, $P10
-    ge rx220_pos, rx220_eos, rxscan223_done
-  rxscan223_scan:
-    set_addr $I10, rxscan223_loop
-    rx220_cur."!mark_push"(0, rx220_pos, $I10)
-  rxscan223_done:
+    set rx206_pos, $P10
+    ge rx206_pos, rx206_eos, rxscan209_done
+  rxscan209_scan:
+    set_addr $I10, rxscan209_loop
+    rx206_cur."!mark_push"(0, rx206_pos, $I10)
+  rxscan209_done:
 .annotate 'line', 80
   # rx literal  "\\\\"
-    add $I11, rx220_pos, 2
-    gt $I11, rx220_eos, rx220_fail
-    sub $I11, rx220_pos, rx220_off
-    substr $S10, rx220_tgt, $I11, 2
-    ne $S10, "\\\\", rx220_fail
-    add rx220_pos, 2
+    add $I11, rx206_pos, 2
+    gt $I11, rx206_eos, rx206_fail
+    sub $I11, rx206_pos, rx206_off
+    substr $S10, rx206_tgt, $I11, 2
+    ne $S10, "\\\\", rx206_fail
+    add rx206_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx220_cur."!cursor_pos"(rx220_pos)
-    $P10 = rx220_cur."quotemod_check"("q")
-    unless $P10, rx220_fail
+    rx206_cur."!cursor_pos"(rx206_pos)
+    $P10 = rx206_cur."quotemod_check"("q")
+    unless $P10, rx206_fail
   # rx pass
-    rx220_cur."!cursor_pass"(rx220_pos, "quote_escape:sym<backslash>")
-    rx220_cur."!cursor_debug"("PASS  ", "quote_escape:sym<backslash>", " at pos=", rx220_pos)
-    .return (rx220_cur)
-  rx220_fail:
-.annotate 'line', 33
-    (rx220_rep, rx220_pos, $I10, $P10) = rx220_cur."!mark_fail"(0)
-    lt rx220_pos, -1, rx220_done
-    eq rx220_pos, -1, rx220_fail
+    rx206_cur."!cursor_pass"(rx206_pos, "quote_escape:sym<backslash>")
+    rx206_cur."!cursor_debug"("PASS  ", "quote_escape:sym<backslash>", " at pos=", rx206_pos)
+    .return (rx206_cur)
+  rx206_restart:
+.annotate 'line', 33
+    rx206_cur."!cursor_debug"("NEXT ", "quote_escape:sym<backslash>")
+  rx206_fail:
+    (rx206_rep, rx206_pos, $I10, $P10) = rx206_cur."!mark_fail"(0)
+    lt rx206_pos, -1, rx206_done
+    eq rx206_pos, -1, rx206_fail
     jump $I10
-  rx220_done:
-    rx220_cur."!cursor_fail"()
-    rx220_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<backslash>")
-    .return (rx220_cur)
+  rx206_done:
+    rx206_cur."!cursor_fail"()
+    rx206_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<backslash>")
+    .return (rx206_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<backslash>"  :subid("70_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<backslash>"  :subid("70_1279529214.68208") :method
 .annotate 'line', 33
-    new $P222, "ResizablePMCArray"
-    push $P222, "\\\\"
-    .return ($P222)
+    new $P208, "ResizablePMCArray"
+    push $P208, "\\\\"
+    .return ($P208)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<stopper>"  :subid("71_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<stopper>"  :subid("71_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx225_tgt
-    .local int rx225_pos
-    .local int rx225_off
-    .local int rx225_eos
-    .local int rx225_rep
-    .local pmc rx225_cur
-    (rx225_cur, rx225_pos, rx225_tgt) = self."!cursor_start"()
-    rx225_cur."!cursor_debug"("START ", "quote_escape:sym<stopper>")
-    .lex unicode:"$\x{a2}", rx225_cur
+    .local string rx211_tgt
+    .local int rx211_pos
+    .local int rx211_off
+    .local int rx211_eos
+    .local int rx211_rep
+    .local pmc rx211_cur
+    (rx211_cur, rx211_pos, rx211_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx211_cur
     .local pmc match
     .lex "$/", match
-    length rx225_eos, rx225_tgt
-    gt rx225_pos, rx225_eos, rx225_done
-    set rx225_off, 0
-    lt rx225_pos, 2, rx225_start
-    sub rx225_off, rx225_pos, 1
-    substr rx225_tgt, rx225_tgt, rx225_off
-  rx225_start:
+    length rx211_eos, rx211_tgt
+    gt rx211_pos, rx211_eos, rx211_done
+    set rx211_off, 0
+    lt rx211_pos, 2, rx211_start
+    sub rx211_off, rx211_pos, 1
+    substr rx211_tgt, rx211_tgt, rx211_off
+  rx211_start:
+    eq $I10, 1, rx211_restart
+    rx211_cur."!cursor_debug"("START ", "quote_escape:sym<stopper>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan228_done
-    goto rxscan228_scan
-  rxscan228_loop:
-    ($P10) = rx225_cur."from"()
+    ne $I10, -1, rxscan214_done
+    goto rxscan214_scan
+  rxscan214_loop:
+    ($P10) = rx211_cur."from"()
     inc $P10
-    set rx225_pos, $P10
-    ge rx225_pos, rx225_eos, rxscan228_done
-  rxscan228_scan:
-    set_addr $I10, rxscan228_loop
-    rx225_cur."!mark_push"(0, rx225_pos, $I10)
-  rxscan228_done:
+    set rx211_pos, $P10
+    ge rx211_pos, rx211_eos, rxscan214_done
+  rxscan214_scan:
+    set_addr $I10, rxscan214_loop
+    rx211_cur."!mark_push"(0, rx211_pos, $I10)
+  rxscan214_done:
 .annotate 'line', 81
   # rx literal  "\\"
-    add $I11, rx225_pos, 1
-    gt $I11, rx225_eos, rx225_fail
-    sub $I11, rx225_pos, rx225_off
-    substr $S10, rx225_tgt, $I11, 1
-    ne $S10, "\\", rx225_fail
-    add rx225_pos, 1
+    add $I11, rx211_pos, 1
+    gt $I11, rx211_eos, rx211_fail
+    sub $I11, rx211_pos, rx211_off
+    substr $S10, rx211_tgt, $I11, 1
+    ne $S10, "\\", rx211_fail
+    add rx211_pos, 1
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx225_cur."!cursor_pos"(rx225_pos)
-    $P10 = rx225_cur."quotemod_check"("q")
-    unless $P10, rx225_fail
+    rx211_cur."!cursor_pos"(rx211_pos)
+    $P10 = rx211_cur."quotemod_check"("q")
+    unless $P10, rx211_fail
   # rx subrule "stopper" subtype=capture negate=
-    rx225_cur."!cursor_pos"(rx225_pos)
-    $P10 = rx225_cur."stopper"()
-    unless $P10, rx225_fail
-    rx225_cur."!mark_push"(0, -1, 0, $P10)
+    rx211_cur."!cursor_pos"(rx211_pos)
+    $P10 = rx211_cur."stopper"()
+    unless $P10, rx211_fail
+    rx211_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("stopper")
-    rx225_pos = $P10."pos"()
+    rx211_pos = $P10."pos"()
   # rx pass
-    rx225_cur."!cursor_pass"(rx225_pos, "quote_escape:sym<stopper>")
-    rx225_cur."!cursor_debug"("PASS  ", "quote_escape:sym<stopper>", " at pos=", rx225_pos)
-    .return (rx225_cur)
-  rx225_fail:
-.annotate 'line', 33
-    (rx225_rep, rx225_pos, $I10, $P10) = rx225_cur."!mark_fail"(0)
-    lt rx225_pos, -1, rx225_done
-    eq rx225_pos, -1, rx225_fail
+    rx211_cur."!cursor_pass"(rx211_pos, "quote_escape:sym<stopper>")
+    rx211_cur."!cursor_debug"("PASS  ", "quote_escape:sym<stopper>", " at pos=", rx211_pos)
+    .return (rx211_cur)
+  rx211_restart:
+.annotate 'line', 33
+    rx211_cur."!cursor_debug"("NEXT ", "quote_escape:sym<stopper>")
+  rx211_fail:
+    (rx211_rep, rx211_pos, $I10, $P10) = rx211_cur."!mark_fail"(0)
+    lt rx211_pos, -1, rx211_done
+    eq rx211_pos, -1, rx211_fail
     jump $I10
-  rx225_done:
-    rx225_cur."!cursor_fail"()
-    rx225_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<stopper>")
-    .return (rx225_cur)
+  rx211_done:
+    rx211_cur."!cursor_fail"()
+    rx211_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<stopper>")
+    .return (rx211_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<stopper>"  :subid("72_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<stopper>"  :subid("72_1279529214.68208") :method
 .annotate 'line', 33
-    new $P227, "ResizablePMCArray"
-    push $P227, "\\"
-    .return ($P227)
+    new $P213, "ResizablePMCArray"
+    push $P213, "\\"
+    .return ($P213)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<bs>"  :subid("73_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<bs>"  :subid("73_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx230_tgt
-    .local int rx230_pos
-    .local int rx230_off
-    .local int rx230_eos
-    .local int rx230_rep
-    .local pmc rx230_cur
-    (rx230_cur, rx230_pos, rx230_tgt) = self."!cursor_start"()
-    rx230_cur."!cursor_debug"("START ", "quote_escape:sym<bs>")
-    .lex unicode:"$\x{a2}", rx230_cur
+    .local string rx216_tgt
+    .local int rx216_pos
+    .local int rx216_off
+    .local int rx216_eos
+    .local int rx216_rep
+    .local pmc rx216_cur
+    (rx216_cur, rx216_pos, rx216_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx216_cur
     .local pmc match
     .lex "$/", match
-    length rx230_eos, rx230_tgt
-    gt rx230_pos, rx230_eos, rx230_done
-    set rx230_off, 0
-    lt rx230_pos, 2, rx230_start
-    sub rx230_off, rx230_pos, 1
-    substr rx230_tgt, rx230_tgt, rx230_off
-  rx230_start:
+    length rx216_eos, rx216_tgt
+    gt rx216_pos, rx216_eos, rx216_done
+    set rx216_off, 0
+    lt rx216_pos, 2, rx216_start
+    sub rx216_off, rx216_pos, 1
+    substr rx216_tgt, rx216_tgt, rx216_off
+  rx216_start:
+    eq $I10, 1, rx216_restart
+    rx216_cur."!cursor_debug"("START ", "quote_escape:sym<bs>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan233_done
-    goto rxscan233_scan
-  rxscan233_loop:
-    ($P10) = rx230_cur."from"()
+    ne $I10, -1, rxscan219_done
+    goto rxscan219_scan
+  rxscan219_loop:
+    ($P10) = rx216_cur."from"()
     inc $P10
-    set rx230_pos, $P10
-    ge rx230_pos, rx230_eos, rxscan233_done
-  rxscan233_scan:
-    set_addr $I10, rxscan233_loop
-    rx230_cur."!mark_push"(0, rx230_pos, $I10)
-  rxscan233_done:
+    set rx216_pos, $P10
+    ge rx216_pos, rx216_eos, rxscan219_done
+  rxscan219_scan:
+    set_addr $I10, rxscan219_loop
+    rx216_cur."!mark_push"(0, rx216_pos, $I10)
+  rxscan219_done:
 .annotate 'line', 83
   # rx literal  "\\b"
-    add $I11, rx230_pos, 2
-    gt $I11, rx230_eos, rx230_fail
-    sub $I11, rx230_pos, rx230_off
-    substr $S10, rx230_tgt, $I11, 2
-    ne $S10, "\\b", rx230_fail
-    add rx230_pos, 2
+    add $I11, rx216_pos, 2
+    gt $I11, rx216_eos, rx216_fail
+    sub $I11, rx216_pos, rx216_off
+    substr $S10, rx216_tgt, $I11, 2
+    ne $S10, "\\b", rx216_fail
+    add rx216_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx230_cur."!cursor_pos"(rx230_pos)
-    $P10 = rx230_cur."quotemod_check"("b")
-    unless $P10, rx230_fail
+    rx216_cur."!cursor_pos"(rx216_pos)
+    $P10 = rx216_cur."quotemod_check"("b")
+    unless $P10, rx216_fail
   # rx pass
-    rx230_cur."!cursor_pass"(rx230_pos, "quote_escape:sym<bs>")
-    rx230_cur."!cursor_debug"("PASS  ", "quote_escape:sym<bs>", " at pos=", rx230_pos)
-    .return (rx230_cur)
-  rx230_fail:
-.annotate 'line', 33
-    (rx230_rep, rx230_pos, $I10, $P10) = rx230_cur."!mark_fail"(0)
-    lt rx230_pos, -1, rx230_done
-    eq rx230_pos, -1, rx230_fail
+    rx216_cur."!cursor_pass"(rx216_pos, "quote_escape:sym<bs>")
+    rx216_cur."!cursor_debug"("PASS  ", "quote_escape:sym<bs>", " at pos=", rx216_pos)
+    .return (rx216_cur)
+  rx216_restart:
+.annotate 'line', 33
+    rx216_cur."!cursor_debug"("NEXT ", "quote_escape:sym<bs>")
+  rx216_fail:
+    (rx216_rep, rx216_pos, $I10, $P10) = rx216_cur."!mark_fail"(0)
+    lt rx216_pos, -1, rx216_done
+    eq rx216_pos, -1, rx216_fail
     jump $I10
-  rx230_done:
-    rx230_cur."!cursor_fail"()
-    rx230_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<bs>")
-    .return (rx230_cur)
+  rx216_done:
+    rx216_cur."!cursor_fail"()
+    rx216_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<bs>")
+    .return (rx216_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<bs>"  :subid("74_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<bs>"  :subid("74_1279529214.68208") :method
 .annotate 'line', 33
-    new $P232, "ResizablePMCArray"
-    push $P232, "\\b"
-    .return ($P232)
+    new $P218, "ResizablePMCArray"
+    push $P218, "\\b"
+    .return ($P218)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<nl>"  :subid("75_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<nl>"  :subid("75_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx235_tgt
-    .local int rx235_pos
-    .local int rx235_off
-    .local int rx235_eos
-    .local int rx235_rep
-    .local pmc rx235_cur
-    (rx235_cur, rx235_pos, rx235_tgt) = self."!cursor_start"()
-    rx235_cur."!cursor_debug"("START ", "quote_escape:sym<nl>")
-    .lex unicode:"$\x{a2}", rx235_cur
+    .local string rx221_tgt
+    .local int rx221_pos
+    .local int rx221_off
+    .local int rx221_eos
+    .local int rx221_rep
+    .local pmc rx221_cur
+    (rx221_cur, rx221_pos, rx221_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx221_cur
     .local pmc match
     .lex "$/", match
-    length rx235_eos, rx235_tgt
-    gt rx235_pos, rx235_eos, rx235_done
-    set rx235_off, 0
-    lt rx235_pos, 2, rx235_start
-    sub rx235_off, rx235_pos, 1
-    substr rx235_tgt, rx235_tgt, rx235_off
-  rx235_start:
+    length rx221_eos, rx221_tgt
+    gt rx221_pos, rx221_eos, rx221_done
+    set rx221_off, 0
+    lt rx221_pos, 2, rx221_start
+    sub rx221_off, rx221_pos, 1
+    substr rx221_tgt, rx221_tgt, rx221_off
+  rx221_start:
+    eq $I10, 1, rx221_restart
+    rx221_cur."!cursor_debug"("START ", "quote_escape:sym<nl>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan238_done
-    goto rxscan238_scan
-  rxscan238_loop:
-    ($P10) = rx235_cur."from"()
+    ne $I10, -1, rxscan224_done
+    goto rxscan224_scan
+  rxscan224_loop:
+    ($P10) = rx221_cur."from"()
     inc $P10
-    set rx235_pos, $P10
-    ge rx235_pos, rx235_eos, rxscan238_done
-  rxscan238_scan:
-    set_addr $I10, rxscan238_loop
-    rx235_cur."!mark_push"(0, rx235_pos, $I10)
-  rxscan238_done:
+    set rx221_pos, $P10
+    ge rx221_pos, rx221_eos, rxscan224_done
+  rxscan224_scan:
+    set_addr $I10, rxscan224_loop
+    rx221_cur."!mark_push"(0, rx221_pos, $I10)
+  rxscan224_done:
 .annotate 'line', 84
   # rx literal  "\\n"
-    add $I11, rx235_pos, 2
-    gt $I11, rx235_eos, rx235_fail
-    sub $I11, rx235_pos, rx235_off
-    substr $S10, rx235_tgt, $I11, 2
-    ne $S10, "\\n", rx235_fail
-    add rx235_pos, 2
+    add $I11, rx221_pos, 2
+    gt $I11, rx221_eos, rx221_fail
+    sub $I11, rx221_pos, rx221_off
+    substr $S10, rx221_tgt, $I11, 2
+    ne $S10, "\\n", rx221_fail
+    add rx221_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx235_cur."!cursor_pos"(rx235_pos)
-    $P10 = rx235_cur."quotemod_check"("b")
-    unless $P10, rx235_fail
+    rx221_cur."!cursor_pos"(rx221_pos)
+    $P10 = rx221_cur."quotemod_check"("b")
+    unless $P10, rx221_fail
   # rx pass
-    rx235_cur."!cursor_pass"(rx235_pos, "quote_escape:sym<nl>")
-    rx235_cur."!cursor_debug"("PASS  ", "quote_escape:sym<nl>", " at pos=", rx235_pos)
-    .return (rx235_cur)
-  rx235_fail:
-.annotate 'line', 33
-    (rx235_rep, rx235_pos, $I10, $P10) = rx235_cur."!mark_fail"(0)
-    lt rx235_pos, -1, rx235_done
-    eq rx235_pos, -1, rx235_fail
+    rx221_cur."!cursor_pass"(rx221_pos, "quote_escape:sym<nl>")
+    rx221_cur."!cursor_debug"("PASS  ", "quote_escape:sym<nl>", " at pos=", rx221_pos)
+    .return (rx221_cur)
+  rx221_restart:
+.annotate 'line', 33
+    rx221_cur."!cursor_debug"("NEXT ", "quote_escape:sym<nl>")
+  rx221_fail:
+    (rx221_rep, rx221_pos, $I10, $P10) = rx221_cur."!mark_fail"(0)
+    lt rx221_pos, -1, rx221_done
+    eq rx221_pos, -1, rx221_fail
     jump $I10
-  rx235_done:
-    rx235_cur."!cursor_fail"()
-    rx235_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<nl>")
-    .return (rx235_cur)
+  rx221_done:
+    rx221_cur."!cursor_fail"()
+    rx221_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<nl>")
+    .return (rx221_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<nl>"  :subid("76_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<nl>"  :subid("76_1279529214.68208") :method
 .annotate 'line', 33
-    new $P237, "ResizablePMCArray"
-    push $P237, "\\n"
-    .return ($P237)
+    new $P223, "ResizablePMCArray"
+    push $P223, "\\n"
+    .return ($P223)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<cr>"  :subid("77_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<cr>"  :subid("77_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx240_tgt
-    .local int rx240_pos
-    .local int rx240_off
-    .local int rx240_eos
-    .local int rx240_rep
-    .local pmc rx240_cur
-    (rx240_cur, rx240_pos, rx240_tgt) = self."!cursor_start"()
-    rx240_cur."!cursor_debug"("START ", "quote_escape:sym<cr>")
-    .lex unicode:"$\x{a2}", rx240_cur
+    .local string rx226_tgt
+    .local int rx226_pos
+    .local int rx226_off
+    .local int rx226_eos
+    .local int rx226_rep
+    .local pmc rx226_cur
+    (rx226_cur, rx226_pos, rx226_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx226_cur
     .local pmc match
     .lex "$/", match
-    length rx240_eos, rx240_tgt
-    gt rx240_pos, rx240_eos, rx240_done
-    set rx240_off, 0
-    lt rx240_pos, 2, rx240_start
-    sub rx240_off, rx240_pos, 1
-    substr rx240_tgt, rx240_tgt, rx240_off
-  rx240_start:
+    length rx226_eos, rx226_tgt
+    gt rx226_pos, rx226_eos, rx226_done
+    set rx226_off, 0
+    lt rx226_pos, 2, rx226_start
+    sub rx226_off, rx226_pos, 1
+    substr rx226_tgt, rx226_tgt, rx226_off
+  rx226_start:
+    eq $I10, 1, rx226_restart
+    rx226_cur."!cursor_debug"("START ", "quote_escape:sym<cr>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan243_done
-    goto rxscan243_scan
-  rxscan243_loop:
-    ($P10) = rx240_cur."from"()
+    ne $I10, -1, rxscan229_done
+    goto rxscan229_scan
+  rxscan229_loop:
+    ($P10) = rx226_cur."from"()
     inc $P10
-    set rx240_pos, $P10
-    ge rx240_pos, rx240_eos, rxscan243_done
-  rxscan243_scan:
-    set_addr $I10, rxscan243_loop
-    rx240_cur."!mark_push"(0, rx240_pos, $I10)
-  rxscan243_done:
+    set rx226_pos, $P10
+    ge rx226_pos, rx226_eos, rxscan229_done
+  rxscan229_scan:
+    set_addr $I10, rxscan229_loop
+    rx226_cur."!mark_push"(0, rx226_pos, $I10)
+  rxscan229_done:
 .annotate 'line', 85
   # rx literal  "\\r"
-    add $I11, rx240_pos, 2
-    gt $I11, rx240_eos, rx240_fail
-    sub $I11, rx240_pos, rx240_off
-    substr $S10, rx240_tgt, $I11, 2
-    ne $S10, "\\r", rx240_fail
-    add rx240_pos, 2
+    add $I11, rx226_pos, 2
+    gt $I11, rx226_eos, rx226_fail
+    sub $I11, rx226_pos, rx226_off
+    substr $S10, rx226_tgt, $I11, 2
+    ne $S10, "\\r", rx226_fail
+    add rx226_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx240_cur."!cursor_pos"(rx240_pos)
-    $P10 = rx240_cur."quotemod_check"("b")
-    unless $P10, rx240_fail
+    rx226_cur."!cursor_pos"(rx226_pos)
+    $P10 = rx226_cur."quotemod_check"("b")
+    unless $P10, rx226_fail
   # rx pass
-    rx240_cur."!cursor_pass"(rx240_pos, "quote_escape:sym<cr>")
-    rx240_cur."!cursor_debug"("PASS  ", "quote_escape:sym<cr>", " at pos=", rx240_pos)
-    .return (rx240_cur)
-  rx240_fail:
-.annotate 'line', 33
-    (rx240_rep, rx240_pos, $I10, $P10) = rx240_cur."!mark_fail"(0)
-    lt rx240_pos, -1, rx240_done
-    eq rx240_pos, -1, rx240_fail
+    rx226_cur."!cursor_pass"(rx226_pos, "quote_escape:sym<cr>")
+    rx226_cur."!cursor_debug"("PASS  ", "quote_escape:sym<cr>", " at pos=", rx226_pos)
+    .return (rx226_cur)
+  rx226_restart:
+.annotate 'line', 33
+    rx226_cur."!cursor_debug"("NEXT ", "quote_escape:sym<cr>")
+  rx226_fail:
+    (rx226_rep, rx226_pos, $I10, $P10) = rx226_cur."!mark_fail"(0)
+    lt rx226_pos, -1, rx226_done
+    eq rx226_pos, -1, rx226_fail
     jump $I10
-  rx240_done:
-    rx240_cur."!cursor_fail"()
-    rx240_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<cr>")
-    .return (rx240_cur)
+  rx226_done:
+    rx226_cur."!cursor_fail"()
+    rx226_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<cr>")
+    .return (rx226_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<cr>"  :subid("78_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<cr>"  :subid("78_1279529214.68208") :method
 .annotate 'line', 33
-    new $P242, "ResizablePMCArray"
-    push $P242, "\\r"
-    .return ($P242)
+    new $P228, "ResizablePMCArray"
+    push $P228, "\\r"
+    .return ($P228)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<tab>"  :subid("79_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<tab>"  :subid("79_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx245_tgt
-    .local int rx245_pos
-    .local int rx245_off
-    .local int rx245_eos
-    .local int rx245_rep
-    .local pmc rx245_cur
-    (rx245_cur, rx245_pos, rx245_tgt) = self."!cursor_start"()
-    rx245_cur."!cursor_debug"("START ", "quote_escape:sym<tab>")
-    .lex unicode:"$\x{a2}", rx245_cur
+    .local string rx231_tgt
+    .local int rx231_pos
+    .local int rx231_off
+    .local int rx231_eos
+    .local int rx231_rep
+    .local pmc rx231_cur
+    (rx231_cur, rx231_pos, rx231_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx231_cur
     .local pmc match
     .lex "$/", match
-    length rx245_eos, rx245_tgt
-    gt rx245_pos, rx245_eos, rx245_done
-    set rx245_off, 0
-    lt rx245_pos, 2, rx245_start
-    sub rx245_off, rx245_pos, 1
-    substr rx245_tgt, rx245_tgt, rx245_off
-  rx245_start:
+    length rx231_eos, rx231_tgt
+    gt rx231_pos, rx231_eos, rx231_done
+    set rx231_off, 0
+    lt rx231_pos, 2, rx231_start
+    sub rx231_off, rx231_pos, 1
+    substr rx231_tgt, rx231_tgt, rx231_off
+  rx231_start:
+    eq $I10, 1, rx231_restart
+    rx231_cur."!cursor_debug"("START ", "quote_escape:sym<tab>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan248_done
-    goto rxscan248_scan
-  rxscan248_loop:
-    ($P10) = rx245_cur."from"()
+    ne $I10, -1, rxscan234_done
+    goto rxscan234_scan
+  rxscan234_loop:
+    ($P10) = rx231_cur."from"()
     inc $P10
-    set rx245_pos, $P10
-    ge rx245_pos, rx245_eos, rxscan248_done
-  rxscan248_scan:
-    set_addr $I10, rxscan248_loop
-    rx245_cur."!mark_push"(0, rx245_pos, $I10)
-  rxscan248_done:
+    set rx231_pos, $P10
+    ge rx231_pos, rx231_eos, rxscan234_done
+  rxscan234_scan:
+    set_addr $I10, rxscan234_loop
+    rx231_cur."!mark_push"(0, rx231_pos, $I10)
+  rxscan234_done:
 .annotate 'line', 86
   # rx literal  "\\t"
-    add $I11, rx245_pos, 2
-    gt $I11, rx245_eos, rx245_fail
-    sub $I11, rx245_pos, rx245_off
-    substr $S10, rx245_tgt, $I11, 2
-    ne $S10, "\\t", rx245_fail
-    add rx245_pos, 2
+    add $I11, rx231_pos, 2
+    gt $I11, rx231_eos, rx231_fail
+    sub $I11, rx231_pos, rx231_off
+    substr $S10, rx231_tgt, $I11, 2
+    ne $S10, "\\t", rx231_fail
+    add rx231_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx245_cur."!cursor_pos"(rx245_pos)
-    $P10 = rx245_cur."quotemod_check"("b")
-    unless $P10, rx245_fail
+    rx231_cur."!cursor_pos"(rx231_pos)
+    $P10 = rx231_cur."quotemod_check"("b")
+    unless $P10, rx231_fail
   # rx pass
-    rx245_cur."!cursor_pass"(rx245_pos, "quote_escape:sym<tab>")
-    rx245_cur."!cursor_debug"("PASS  ", "quote_escape:sym<tab>", " at pos=", rx245_pos)
-    .return (rx245_cur)
-  rx245_fail:
-.annotate 'line', 33
-    (rx245_rep, rx245_pos, $I10, $P10) = rx245_cur."!mark_fail"(0)
-    lt rx245_pos, -1, rx245_done
-    eq rx245_pos, -1, rx245_fail
+    rx231_cur."!cursor_pass"(rx231_pos, "quote_escape:sym<tab>")
+    rx231_cur."!cursor_debug"("PASS  ", "quote_escape:sym<tab>", " at pos=", rx231_pos)
+    .return (rx231_cur)
+  rx231_restart:
+.annotate 'line', 33
+    rx231_cur."!cursor_debug"("NEXT ", "quote_escape:sym<tab>")
+  rx231_fail:
+    (rx231_rep, rx231_pos, $I10, $P10) = rx231_cur."!mark_fail"(0)
+    lt rx231_pos, -1, rx231_done
+    eq rx231_pos, -1, rx231_fail
     jump $I10
-  rx245_done:
-    rx245_cur."!cursor_fail"()
-    rx245_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<tab>")
-    .return (rx245_cur)
+  rx231_done:
+    rx231_cur."!cursor_fail"()
+    rx231_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<tab>")
+    .return (rx231_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<tab>"  :subid("80_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<tab>"  :subid("80_1279529214.68208") :method
 .annotate 'line', 33
-    new $P247, "ResizablePMCArray"
-    push $P247, "\\t"
-    .return ($P247)
+    new $P233, "ResizablePMCArray"
+    push $P233, "\\t"
+    .return ($P233)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<ff>"  :subid("81_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<ff>"  :subid("81_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx250_tgt
-    .local int rx250_pos
-    .local int rx250_off
-    .local int rx250_eos
-    .local int rx250_rep
-    .local pmc rx250_cur
-    (rx250_cur, rx250_pos, rx250_tgt) = self."!cursor_start"()
-    rx250_cur."!cursor_debug"("START ", "quote_escape:sym<ff>")
-    .lex unicode:"$\x{a2}", rx250_cur
+    .local string rx236_tgt
+    .local int rx236_pos
+    .local int rx236_off
+    .local int rx236_eos
+    .local int rx236_rep
+    .local pmc rx236_cur
+    (rx236_cur, rx236_pos, rx236_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx236_cur
     .local pmc match
     .lex "$/", match
-    length rx250_eos, rx250_tgt
-    gt rx250_pos, rx250_eos, rx250_done
-    set rx250_off, 0
-    lt rx250_pos, 2, rx250_start
-    sub rx250_off, rx250_pos, 1
-    substr rx250_tgt, rx250_tgt, rx250_off
-  rx250_start:
+    length rx236_eos, rx236_tgt
+    gt rx236_pos, rx236_eos, rx236_done
+    set rx236_off, 0
+    lt rx236_pos, 2, rx236_start
+    sub rx236_off, rx236_pos, 1
+    substr rx236_tgt, rx236_tgt, rx236_off
+  rx236_start:
+    eq $I10, 1, rx236_restart
+    rx236_cur."!cursor_debug"("START ", "quote_escape:sym<ff>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan253_done
-    goto rxscan253_scan
-  rxscan253_loop:
-    ($P10) = rx250_cur."from"()
+    ne $I10, -1, rxscan239_done
+    goto rxscan239_scan
+  rxscan239_loop:
+    ($P10) = rx236_cur."from"()
     inc $P10
-    set rx250_pos, $P10
-    ge rx250_pos, rx250_eos, rxscan253_done
-  rxscan253_scan:
-    set_addr $I10, rxscan253_loop
-    rx250_cur."!mark_push"(0, rx250_pos, $I10)
-  rxscan253_done:
+    set rx236_pos, $P10
+    ge rx236_pos, rx236_eos, rxscan239_done
+  rxscan239_scan:
+    set_addr $I10, rxscan239_loop
+    rx236_cur."!mark_push"(0, rx236_pos, $I10)
+  rxscan239_done:
 .annotate 'line', 87
   # rx literal  "\\f"
-    add $I11, rx250_pos, 2
-    gt $I11, rx250_eos, rx250_fail
-    sub $I11, rx250_pos, rx250_off
-    substr $S10, rx250_tgt, $I11, 2
-    ne $S10, "\\f", rx250_fail
-    add rx250_pos, 2
+    add $I11, rx236_pos, 2
+    gt $I11, rx236_eos, rx236_fail
+    sub $I11, rx236_pos, rx236_off
+    substr $S10, rx236_tgt, $I11, 2
+    ne $S10, "\\f", rx236_fail
+    add rx236_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx250_cur."!cursor_pos"(rx250_pos)
-    $P10 = rx250_cur."quotemod_check"("b")
-    unless $P10, rx250_fail
+    rx236_cur."!cursor_pos"(rx236_pos)
+    $P10 = rx236_cur."quotemod_check"("b")
+    unless $P10, rx236_fail
   # rx pass
-    rx250_cur."!cursor_pass"(rx250_pos, "quote_escape:sym<ff>")
-    rx250_cur."!cursor_debug"("PASS  ", "quote_escape:sym<ff>", " at pos=", rx250_pos)
-    .return (rx250_cur)
-  rx250_fail:
-.annotate 'line', 33
-    (rx250_rep, rx250_pos, $I10, $P10) = rx250_cur."!mark_fail"(0)
-    lt rx250_pos, -1, rx250_done
-    eq rx250_pos, -1, rx250_fail
+    rx236_cur."!cursor_pass"(rx236_pos, "quote_escape:sym<ff>")
+    rx236_cur."!cursor_debug"("PASS  ", "quote_escape:sym<ff>", " at pos=", rx236_pos)
+    .return (rx236_cur)
+  rx236_restart:
+.annotate 'line', 33
+    rx236_cur."!cursor_debug"("NEXT ", "quote_escape:sym<ff>")
+  rx236_fail:
+    (rx236_rep, rx236_pos, $I10, $P10) = rx236_cur."!mark_fail"(0)
+    lt rx236_pos, -1, rx236_done
+    eq rx236_pos, -1, rx236_fail
     jump $I10
-  rx250_done:
-    rx250_cur."!cursor_fail"()
-    rx250_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<ff>")
-    .return (rx250_cur)
+  rx236_done:
+    rx236_cur."!cursor_fail"()
+    rx236_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<ff>")
+    .return (rx236_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<ff>"  :subid("82_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<ff>"  :subid("82_1279529214.68208") :method
 .annotate 'line', 33
-    new $P252, "ResizablePMCArray"
-    push $P252, "\\f"
-    .return ($P252)
+    new $P238, "ResizablePMCArray"
+    push $P238, "\\f"
+    .return ($P238)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<esc>"  :subid("83_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<esc>"  :subid("83_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx255_tgt
-    .local int rx255_pos
-    .local int rx255_off
-    .local int rx255_eos
-    .local int rx255_rep
-    .local pmc rx255_cur
-    (rx255_cur, rx255_pos, rx255_tgt) = self."!cursor_start"()
-    rx255_cur."!cursor_debug"("START ", "quote_escape:sym<esc>")
-    .lex unicode:"$\x{a2}", rx255_cur
+    .local string rx241_tgt
+    .local int rx241_pos
+    .local int rx241_off
+    .local int rx241_eos
+    .local int rx241_rep
+    .local pmc rx241_cur
+    (rx241_cur, rx241_pos, rx241_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx241_cur
     .local pmc match
     .lex "$/", match
-    length rx255_eos, rx255_tgt
-    gt rx255_pos, rx255_eos, rx255_done
-    set rx255_off, 0
-    lt rx255_pos, 2, rx255_start
-    sub rx255_off, rx255_pos, 1
-    substr rx255_tgt, rx255_tgt, rx255_off
-  rx255_start:
+    length rx241_eos, rx241_tgt
+    gt rx241_pos, rx241_eos, rx241_done
+    set rx241_off, 0
+    lt rx241_pos, 2, rx241_start
+    sub rx241_off, rx241_pos, 1
+    substr rx241_tgt, rx241_tgt, rx241_off
+  rx241_start:
+    eq $I10, 1, rx241_restart
+    rx241_cur."!cursor_debug"("START ", "quote_escape:sym<esc>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan258_done
-    goto rxscan258_scan
-  rxscan258_loop:
-    ($P10) = rx255_cur."from"()
+    ne $I10, -1, rxscan244_done
+    goto rxscan244_scan
+  rxscan244_loop:
+    ($P10) = rx241_cur."from"()
     inc $P10
-    set rx255_pos, $P10
-    ge rx255_pos, rx255_eos, rxscan258_done
-  rxscan258_scan:
-    set_addr $I10, rxscan258_loop
-    rx255_cur."!mark_push"(0, rx255_pos, $I10)
-  rxscan258_done:
+    set rx241_pos, $P10
+    ge rx241_pos, rx241_eos, rxscan244_done
+  rxscan244_scan:
+    set_addr $I10, rxscan244_loop
+    rx241_cur."!mark_push"(0, rx241_pos, $I10)
+  rxscan244_done:
 .annotate 'line', 88
   # rx literal  "\\e"
-    add $I11, rx255_pos, 2
-    gt $I11, rx255_eos, rx255_fail
-    sub $I11, rx255_pos, rx255_off
-    substr $S10, rx255_tgt, $I11, 2
-    ne $S10, "\\e", rx255_fail
-    add rx255_pos, 2
+    add $I11, rx241_pos, 2
+    gt $I11, rx241_eos, rx241_fail
+    sub $I11, rx241_pos, rx241_off
+    substr $S10, rx241_tgt, $I11, 2
+    ne $S10, "\\e", rx241_fail
+    add rx241_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx255_cur."!cursor_pos"(rx255_pos)
-    $P10 = rx255_cur."quotemod_check"("b")
-    unless $P10, rx255_fail
+    rx241_cur."!cursor_pos"(rx241_pos)
+    $P10 = rx241_cur."quotemod_check"("b")
+    unless $P10, rx241_fail
   # rx pass
-    rx255_cur."!cursor_pass"(rx255_pos, "quote_escape:sym<esc>")
-    rx255_cur."!cursor_debug"("PASS  ", "quote_escape:sym<esc>", " at pos=", rx255_pos)
-    .return (rx255_cur)
-  rx255_fail:
-.annotate 'line', 33
-    (rx255_rep, rx255_pos, $I10, $P10) = rx255_cur."!mark_fail"(0)
-    lt rx255_pos, -1, rx255_done
-    eq rx255_pos, -1, rx255_fail
+    rx241_cur."!cursor_pass"(rx241_pos, "quote_escape:sym<esc>")
+    rx241_cur."!cursor_debug"("PASS  ", "quote_escape:sym<esc>", " at pos=", rx241_pos)
+    .return (rx241_cur)
+  rx241_restart:
+.annotate 'line', 33
+    rx241_cur."!cursor_debug"("NEXT ", "quote_escape:sym<esc>")
+  rx241_fail:
+    (rx241_rep, rx241_pos, $I10, $P10) = rx241_cur."!mark_fail"(0)
+    lt rx241_pos, -1, rx241_done
+    eq rx241_pos, -1, rx241_fail
     jump $I10
-  rx255_done:
-    rx255_cur."!cursor_fail"()
-    rx255_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<esc>")
-    .return (rx255_cur)
+  rx241_done:
+    rx241_cur."!cursor_fail"()
+    rx241_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<esc>")
+    .return (rx241_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<esc>"  :subid("84_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<esc>"  :subid("84_1279529214.68208") :method
 .annotate 'line', 33
-    new $P257, "ResizablePMCArray"
-    push $P257, "\\e"
-    .return ($P257)
+    new $P243, "ResizablePMCArray"
+    push $P243, "\\e"
+    .return ($P243)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<hex>"  :subid("85_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<hex>"  :subid("85_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx260_tgt
-    .local int rx260_pos
-    .local int rx260_off
-    .local int rx260_eos
-    .local int rx260_rep
-    .local pmc rx260_cur
-    (rx260_cur, rx260_pos, rx260_tgt) = self."!cursor_start"()
-    rx260_cur."!cursor_debug"("START ", "quote_escape:sym<hex>")
-    .lex unicode:"$\x{a2}", rx260_cur
+    .local string rx246_tgt
+    .local int rx246_pos
+    .local int rx246_off
+    .local int rx246_eos
+    .local int rx246_rep
+    .local pmc rx246_cur
+    (rx246_cur, rx246_pos, rx246_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx246_cur
     .local pmc match
     .lex "$/", match
-    length rx260_eos, rx260_tgt
-    gt rx260_pos, rx260_eos, rx260_done
-    set rx260_off, 0
-    lt rx260_pos, 2, rx260_start
-    sub rx260_off, rx260_pos, 1
-    substr rx260_tgt, rx260_tgt, rx260_off
-  rx260_start:
+    length rx246_eos, rx246_tgt
+    gt rx246_pos, rx246_eos, rx246_done
+    set rx246_off, 0
+    lt rx246_pos, 2, rx246_start
+    sub rx246_off, rx246_pos, 1
+    substr rx246_tgt, rx246_tgt, rx246_off
+  rx246_start:
+    eq $I10, 1, rx246_restart
+    rx246_cur."!cursor_debug"("START ", "quote_escape:sym<hex>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan263_done
-    goto rxscan263_scan
-  rxscan263_loop:
-    ($P10) = rx260_cur."from"()
+    ne $I10, -1, rxscan249_done
+    goto rxscan249_scan
+  rxscan249_loop:
+    ($P10) = rx246_cur."from"()
     inc $P10
-    set rx260_pos, $P10
-    ge rx260_pos, rx260_eos, rxscan263_done
-  rxscan263_scan:
-    set_addr $I10, rxscan263_loop
-    rx260_cur."!mark_push"(0, rx260_pos, $I10)
-  rxscan263_done:
+    set rx246_pos, $P10
+    ge rx246_pos, rx246_eos, rxscan249_done
+  rxscan249_scan:
+    set_addr $I10, rxscan249_loop
+    rx246_cur."!mark_push"(0, rx246_pos, $I10)
+  rxscan249_done:
 .annotate 'line', 90
   # rx literal  unicode:"\\x"
-    add $I11, rx260_pos, 2
-    gt $I11, rx260_eos, rx260_fail
-    sub $I11, rx260_pos, rx260_off
-    substr $S10, rx260_tgt, $I11, 2
-    ne $S10, unicode:"\\x", rx260_fail
-    add rx260_pos, 2
+    add $I11, rx246_pos, 2
+    gt $I11, rx246_eos, rx246_fail
+    sub $I11, rx246_pos, rx246_off
+    substr $S10, rx246_tgt, $I11, 2
+    ne $S10, unicode:"\\x", rx246_fail
+    add rx246_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx260_cur."!cursor_pos"(rx260_pos)
-    $P10 = rx260_cur."quotemod_check"("b")
-    unless $P10, rx260_fail
-  alt264_0:
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."quotemod_check"("b")
+    unless $P10, rx246_fail
+  alt250_0:
 .annotate 'line', 91
-    set_addr $I10, alt264_1
-    rx260_cur."!mark_push"(0, rx260_pos, $I10)
+    set_addr $I10, alt250_1
+    rx246_cur."!mark_push"(0, rx246_pos, $I10)
   # rx subrule "hexint" subtype=capture negate=
-    rx260_cur."!cursor_pos"(rx260_pos)
-    $P10 = rx260_cur."hexint"()
-    unless $P10, rx260_fail
-    rx260_cur."!mark_push"(0, -1, 0, $P10)
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."hexint"()
+    unless $P10, rx246_fail
+    rx246_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("hexint")
-    rx260_pos = $P10."pos"()
-    goto alt264_end
-  alt264_1:
+    rx246_pos = $P10."pos"()
+    goto alt250_end
+  alt250_1:
   # rx literal  "["
-    add $I11, rx260_pos, 1
-    gt $I11, rx260_eos, rx260_fail
-    sub $I11, rx260_pos, rx260_off
-    substr $S10, rx260_tgt, $I11, 1
-    ne $S10, "[", rx260_fail
-    add rx260_pos, 1
+    add $I11, rx246_pos, 1
+    gt $I11, rx246_eos, rx246_fail
+    sub $I11, rx246_pos, rx246_off
+    substr $S10, rx246_tgt, $I11, 1
+    ne $S10, "[", rx246_fail
+    add rx246_pos, 1
   # rx subrule "hexints" subtype=capture negate=
-    rx260_cur."!cursor_pos"(rx260_pos)
-    $P10 = rx260_cur."hexints"()
-    unless $P10, rx260_fail
-    rx260_cur."!mark_push"(0, -1, 0, $P10)
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."hexints"()
+    unless $P10, rx246_fail
+    rx246_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("hexints")
-    rx260_pos = $P10."pos"()
+    rx246_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx260_pos, 1
-    gt $I11, rx260_eos, rx260_fail
-    sub $I11, rx260_pos, rx260_off
-    substr $S10, rx260_tgt, $I11, 1
-    ne $S10, "]", rx260_fail
-    add rx260_pos, 1
-  alt264_end:
+    add $I11, rx246_pos, 1
+    gt $I11, rx246_eos, rx246_fail
+    sub $I11, rx246_pos, rx246_off
+    substr $S10, rx246_tgt, $I11, 1
+    ne $S10, "]", rx246_fail
+    add rx246_pos, 1
+  alt250_end:
 .annotate 'line', 89
   # rx pass
-    rx260_cur."!cursor_pass"(rx260_pos, "quote_escape:sym<hex>")
-    rx260_cur."!cursor_debug"("PASS  ", "quote_escape:sym<hex>", " at pos=", rx260_pos)
-    .return (rx260_cur)
-  rx260_fail:
-.annotate 'line', 33
-    (rx260_rep, rx260_pos, $I10, $P10) = rx260_cur."!mark_fail"(0)
-    lt rx260_pos, -1, rx260_done
-    eq rx260_pos, -1, rx260_fail
+    rx246_cur."!cursor_pass"(rx246_pos, "quote_escape:sym<hex>")
+    rx246_cur."!cursor_debug"("PASS  ", "quote_escape:sym<hex>", " at pos=", rx246_pos)
+    .return (rx246_cur)
+  rx246_restart:
+.annotate 'line', 33
+    rx246_cur."!cursor_debug"("NEXT ", "quote_escape:sym<hex>")
+  rx246_fail:
+    (rx246_rep, rx246_pos, $I10, $P10) = rx246_cur."!mark_fail"(0)
+    lt rx246_pos, -1, rx246_done
+    eq rx246_pos, -1, rx246_fail
     jump $I10
-  rx260_done:
-    rx260_cur."!cursor_fail"()
-    rx260_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<hex>")
-    .return (rx260_cur)
+  rx246_done:
+    rx246_cur."!cursor_fail"()
+    rx246_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<hex>")
+    .return (rx246_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<hex>"  :subid("86_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<hex>"  :subid("86_1279529214.68208") :method
 .annotate 'line', 33
-    new $P262, "ResizablePMCArray"
-    push $P262, unicode:"\\x"
-    .return ($P262)
+    new $P248, "ResizablePMCArray"
+    push $P248, unicode:"\\x"
+    .return ($P248)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<oct>"  :subid("87_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<oct>"  :subid("87_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx266_tgt
-    .local int rx266_pos
-    .local int rx266_off
-    .local int rx266_eos
-    .local int rx266_rep
-    .local pmc rx266_cur
-    (rx266_cur, rx266_pos, rx266_tgt) = self."!cursor_start"()
-    rx266_cur."!cursor_debug"("START ", "quote_escape:sym<oct>")
-    .lex unicode:"$\x{a2}", rx266_cur
+    .local string rx252_tgt
+    .local int rx252_pos
+    .local int rx252_off
+    .local int rx252_eos
+    .local int rx252_rep
+    .local pmc rx252_cur
+    (rx252_cur, rx252_pos, rx252_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx252_cur
     .local pmc match
     .lex "$/", match
-    length rx266_eos, rx266_tgt
-    gt rx266_pos, rx266_eos, rx266_done
-    set rx266_off, 0
-    lt rx266_pos, 2, rx266_start
-    sub rx266_off, rx266_pos, 1
-    substr rx266_tgt, rx266_tgt, rx266_off
-  rx266_start:
+    length rx252_eos, rx252_tgt
+    gt rx252_pos, rx252_eos, rx252_done
+    set rx252_off, 0
+    lt rx252_pos, 2, rx252_start
+    sub rx252_off, rx252_pos, 1
+    substr rx252_tgt, rx252_tgt, rx252_off
+  rx252_start:
+    eq $I10, 1, rx252_restart
+    rx252_cur."!cursor_debug"("START ", "quote_escape:sym<oct>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan269_done
-    goto rxscan269_scan
-  rxscan269_loop:
-    ($P10) = rx266_cur."from"()
+    ne $I10, -1, rxscan255_done
+    goto rxscan255_scan
+  rxscan255_loop:
+    ($P10) = rx252_cur."from"()
     inc $P10
-    set rx266_pos, $P10
-    ge rx266_pos, rx266_eos, rxscan269_done
-  rxscan269_scan:
-    set_addr $I10, rxscan269_loop
-    rx266_cur."!mark_push"(0, rx266_pos, $I10)
-  rxscan269_done:
+    set rx252_pos, $P10
+    ge rx252_pos, rx252_eos, rxscan255_done
+  rxscan255_scan:
+    set_addr $I10, rxscan255_loop
+    rx252_cur."!mark_push"(0, rx252_pos, $I10)
+  rxscan255_done:
 .annotate 'line', 94
   # rx literal  "\\o"
-    add $I11, rx266_pos, 2
-    gt $I11, rx266_eos, rx266_fail
-    sub $I11, rx266_pos, rx266_off
-    substr $S10, rx266_tgt, $I11, 2
-    ne $S10, "\\o", rx266_fail
-    add rx266_pos, 2
+    add $I11, rx252_pos, 2
+    gt $I11, rx252_eos, rx252_fail
+    sub $I11, rx252_pos, rx252_off
+    substr $S10, rx252_tgt, $I11, 2
+    ne $S10, "\\o", rx252_fail
+    add rx252_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx266_cur."!cursor_pos"(rx266_pos)
-    $P10 = rx266_cur."quotemod_check"("b")
-    unless $P10, rx266_fail
-  alt270_0:
+    rx252_cur."!cursor_pos"(rx252_pos)
+    $P10 = rx252_cur."quotemod_check"("b")
+    unless $P10, rx252_fail
+  alt256_0:
 .annotate 'line', 95
-    set_addr $I10, alt270_1
-    rx266_cur."!mark_push"(0, rx266_pos, $I10)
+    set_addr $I10, alt256_1
+    rx252_cur."!mark_push"(0, rx252_pos, $I10)
   # rx subrule "octint" subtype=capture negate=
-    rx266_cur."!cursor_pos"(rx266_pos)
-    $P10 = rx266_cur."octint"()
-    unless $P10, rx266_fail
-    rx266_cur."!mark_push"(0, -1, 0, $P10)
+    rx252_cur."!cursor_pos"(rx252_pos)
+    $P10 = rx252_cur."octint"()
+    unless $P10, rx252_fail
+    rx252_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("octint")
-    rx266_pos = $P10."pos"()
-    goto alt270_end
-  alt270_1:
+    rx252_pos = $P10."pos"()
+    goto alt256_end
+  alt256_1:
   # rx literal  "["
-    add $I11, rx266_pos, 1
-    gt $I11, rx266_eos, rx266_fail
-    sub $I11, rx266_pos, rx266_off
-    substr $S10, rx266_tgt, $I11, 1
-    ne $S10, "[", rx266_fail
-    add rx266_pos, 1
+    add $I11, rx252_pos, 1
+    gt $I11, rx252_eos, rx252_fail
+    sub $I11, rx252_pos, rx252_off
+    substr $S10, rx252_tgt, $I11, 1
+    ne $S10, "[", rx252_fail
+    add rx252_pos, 1
   # rx subrule "octints" subtype=capture negate=
-    rx266_cur."!cursor_pos"(rx266_pos)
-    $P10 = rx266_cur."octints"()
-    unless $P10, rx266_fail
-    rx266_cur."!mark_push"(0, -1, 0, $P10)
+    rx252_cur."!cursor_pos"(rx252_pos)
+    $P10 = rx252_cur."octints"()
+    unless $P10, rx252_fail
+    rx252_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("octints")
-    rx266_pos = $P10."pos"()
+    rx252_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx266_pos, 1
-    gt $I11, rx266_eos, rx266_fail
-    sub $I11, rx266_pos, rx266_off
-    substr $S10, rx266_tgt, $I11, 1
-    ne $S10, "]", rx266_fail
-    add rx266_pos, 1
-  alt270_end:
+    add $I11, rx252_pos, 1
+    gt $I11, rx252_eos, rx252_fail
+    sub $I11, rx252_pos, rx252_off
+    substr $S10, rx252_tgt, $I11, 1
+    ne $S10, "]", rx252_fail
+    add rx252_pos, 1
+  alt256_end:
 .annotate 'line', 93
   # rx pass
-    rx266_cur."!cursor_pass"(rx266_pos, "quote_escape:sym<oct>")
-    rx266_cur."!cursor_debug"("PASS  ", "quote_escape:sym<oct>", " at pos=", rx266_pos)
-    .return (rx266_cur)
-  rx266_fail:
-.annotate 'line', 33
-    (rx266_rep, rx266_pos, $I10, $P10) = rx266_cur."!mark_fail"(0)
-    lt rx266_pos, -1, rx266_done
-    eq rx266_pos, -1, rx266_fail
+    rx252_cur."!cursor_pass"(rx252_pos, "quote_escape:sym<oct>")
+    rx252_cur."!cursor_debug"("PASS  ", "quote_escape:sym<oct>", " at pos=", rx252_pos)
+    .return (rx252_cur)
+  rx252_restart:
+.annotate 'line', 33
+    rx252_cur."!cursor_debug"("NEXT ", "quote_escape:sym<oct>")
+  rx252_fail:
+    (rx252_rep, rx252_pos, $I10, $P10) = rx252_cur."!mark_fail"(0)
+    lt rx252_pos, -1, rx252_done
+    eq rx252_pos, -1, rx252_fail
     jump $I10
-  rx266_done:
-    rx266_cur."!cursor_fail"()
-    rx266_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<oct>")
-    .return (rx266_cur)
+  rx252_done:
+    rx252_cur."!cursor_fail"()
+    rx252_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<oct>")
+    .return (rx252_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<oct>"  :subid("88_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<oct>"  :subid("88_1279529214.68208") :method
 .annotate 'line', 33
-    new $P268, "ResizablePMCArray"
-    push $P268, "\\o"
-    .return ($P268)
+    new $P254, "ResizablePMCArray"
+    push $P254, "\\o"
+    .return ($P254)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<chr>"  :subid("89_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<chr>"  :subid("89_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx272_tgt
-    .local int rx272_pos
-    .local int rx272_off
-    .local int rx272_eos
-    .local int rx272_rep
-    .local pmc rx272_cur
-    (rx272_cur, rx272_pos, rx272_tgt) = self."!cursor_start"()
-    rx272_cur."!cursor_debug"("START ", "quote_escape:sym<chr>")
-    .lex unicode:"$\x{a2}", rx272_cur
+    .local string rx258_tgt
+    .local int rx258_pos
+    .local int rx258_off
+    .local int rx258_eos
+    .local int rx258_rep
+    .local pmc rx258_cur
+    (rx258_cur, rx258_pos, rx258_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx258_cur
     .local pmc match
     .lex "$/", match
-    length rx272_eos, rx272_tgt
-    gt rx272_pos, rx272_eos, rx272_done
-    set rx272_off, 0
-    lt rx272_pos, 2, rx272_start
-    sub rx272_off, rx272_pos, 1
-    substr rx272_tgt, rx272_tgt, rx272_off
-  rx272_start:
+    length rx258_eos, rx258_tgt
+    gt rx258_pos, rx258_eos, rx258_done
+    set rx258_off, 0
+    lt rx258_pos, 2, rx258_start
+    sub rx258_off, rx258_pos, 1
+    substr rx258_tgt, rx258_tgt, rx258_off
+  rx258_start:
+    eq $I10, 1, rx258_restart
+    rx258_cur."!cursor_debug"("START ", "quote_escape:sym<chr>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan275_done
-    goto rxscan275_scan
-  rxscan275_loop:
-    ($P10) = rx272_cur."from"()
+    ne $I10, -1, rxscan261_done
+    goto rxscan261_scan
+  rxscan261_loop:
+    ($P10) = rx258_cur."from"()
     inc $P10
-    set rx272_pos, $P10
-    ge rx272_pos, rx272_eos, rxscan275_done
-  rxscan275_scan:
-    set_addr $I10, rxscan275_loop
-    rx272_cur."!mark_push"(0, rx272_pos, $I10)
-  rxscan275_done:
+    set rx258_pos, $P10
+    ge rx258_pos, rx258_eos, rxscan261_done
+  rxscan261_scan:
+    set_addr $I10, rxscan261_loop
+    rx258_cur."!mark_push"(0, rx258_pos, $I10)
+  rxscan261_done:
 .annotate 'line', 97
   # rx literal  "\\c"
-    add $I11, rx272_pos, 2
-    gt $I11, rx272_eos, rx272_fail
-    sub $I11, rx272_pos, rx272_off
-    substr $S10, rx272_tgt, $I11, 2
-    ne $S10, "\\c", rx272_fail
-    add rx272_pos, 2
+    add $I11, rx258_pos, 2
+    gt $I11, rx258_eos, rx258_fail
+    sub $I11, rx258_pos, rx258_off
+    substr $S10, rx258_tgt, $I11, 2
+    ne $S10, "\\c", rx258_fail
+    add rx258_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx272_cur."!cursor_pos"(rx272_pos)
-    $P10 = rx272_cur."quotemod_check"("b")
-    unless $P10, rx272_fail
+    rx258_cur."!cursor_pos"(rx258_pos)
+    $P10 = rx258_cur."quotemod_check"("b")
+    unless $P10, rx258_fail
   # rx subrule "charspec" subtype=capture negate=
-    rx272_cur."!cursor_pos"(rx272_pos)
-    $P10 = rx272_cur."charspec"()
-    unless $P10, rx272_fail
-    rx272_cur."!mark_push"(0, -1, 0, $P10)
+    rx258_cur."!cursor_pos"(rx258_pos)
+    $P10 = rx258_cur."charspec"()
+    unless $P10, rx258_fail
+    rx258_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("charspec")
-    rx272_pos = $P10."pos"()
+    rx258_pos = $P10."pos"()
   # rx pass
-    rx272_cur."!cursor_pass"(rx272_pos, "quote_escape:sym<chr>")
-    rx272_cur."!cursor_debug"("PASS  ", "quote_escape:sym<chr>", " at pos=", rx272_pos)
-    .return (rx272_cur)
-  rx272_fail:
-.annotate 'line', 33
-    (rx272_rep, rx272_pos, $I10, $P10) = rx272_cur."!mark_fail"(0)
-    lt rx272_pos, -1, rx272_done
-    eq rx272_pos, -1, rx272_fail
+    rx258_cur."!cursor_pass"(rx258_pos, "quote_escape:sym<chr>")
+    rx258_cur."!cursor_debug"("PASS  ", "quote_escape:sym<chr>", " at pos=", rx258_pos)
+    .return (rx258_cur)
+  rx258_restart:
+.annotate 'line', 33
+    rx258_cur."!cursor_debug"("NEXT ", "quote_escape:sym<chr>")
+  rx258_fail:
+    (rx258_rep, rx258_pos, $I10, $P10) = rx258_cur."!mark_fail"(0)
+    lt rx258_pos, -1, rx258_done
+    eq rx258_pos, -1, rx258_fail
     jump $I10
-  rx272_done:
-    rx272_cur."!cursor_fail"()
-    rx272_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<chr>")
-    .return (rx272_cur)
+  rx258_done:
+    rx258_cur."!cursor_fail"()
+    rx258_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<chr>")
+    .return (rx258_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<chr>"  :subid("90_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<chr>"  :subid("90_1279529214.68208") :method
 .annotate 'line', 33
-    new $P274, "ResizablePMCArray"
-    push $P274, "\\c"
-    .return ($P274)
+    new $P260, "ResizablePMCArray"
+    push $P260, "\\c"
+    .return ($P260)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<0>"  :subid("91_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<0>"  :subid("91_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx277_tgt
-    .local int rx277_pos
-    .local int rx277_off
-    .local int rx277_eos
-    .local int rx277_rep
-    .local pmc rx277_cur
-    (rx277_cur, rx277_pos, rx277_tgt) = self."!cursor_start"()
-    rx277_cur."!cursor_debug"("START ", "quote_escape:sym<0>")
-    .lex unicode:"$\x{a2}", rx277_cur
+    .local string rx263_tgt
+    .local int rx263_pos
+    .local int rx263_off
+    .local int rx263_eos
+    .local int rx263_rep
+    .local pmc rx263_cur
+    (rx263_cur, rx263_pos, rx263_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx263_cur
     .local pmc match
     .lex "$/", match
-    length rx277_eos, rx277_tgt
-    gt rx277_pos, rx277_eos, rx277_done
-    set rx277_off, 0
-    lt rx277_pos, 2, rx277_start
-    sub rx277_off, rx277_pos, 1
-    substr rx277_tgt, rx277_tgt, rx277_off
-  rx277_start:
+    length rx263_eos, rx263_tgt
+    gt rx263_pos, rx263_eos, rx263_done
+    set rx263_off, 0
+    lt rx263_pos, 2, rx263_start
+    sub rx263_off, rx263_pos, 1
+    substr rx263_tgt, rx263_tgt, rx263_off
+  rx263_start:
+    eq $I10, 1, rx263_restart
+    rx263_cur."!cursor_debug"("START ", "quote_escape:sym<0>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan280_done
-    goto rxscan280_scan
-  rxscan280_loop:
-    ($P10) = rx277_cur."from"()
+    ne $I10, -1, rxscan266_done
+    goto rxscan266_scan
+  rxscan266_loop:
+    ($P10) = rx263_cur."from"()
     inc $P10
-    set rx277_pos, $P10
-    ge rx277_pos, rx277_eos, rxscan280_done
-  rxscan280_scan:
-    set_addr $I10, rxscan280_loop
-    rx277_cur."!mark_push"(0, rx277_pos, $I10)
-  rxscan280_done:
+    set rx263_pos, $P10
+    ge rx263_pos, rx263_eos, rxscan266_done
+  rxscan266_scan:
+    set_addr $I10, rxscan266_loop
+    rx263_cur."!mark_push"(0, rx263_pos, $I10)
+  rxscan266_done:
 .annotate 'line', 98
   # rx literal  "\\"
-    add $I11, rx277_pos, 1
-    gt $I11, rx277_eos, rx277_fail
-    sub $I11, rx277_pos, rx277_off
-    substr $S10, rx277_tgt, $I11, 1
-    ne $S10, "\\", rx277_fail
-    add rx277_pos, 1
+    add $I11, rx263_pos, 1
+    gt $I11, rx263_eos, rx263_fail
+    sub $I11, rx263_pos, rx263_off
+    substr $S10, rx263_tgt, $I11, 1
+    ne $S10, "\\", rx263_fail
+    add rx263_pos, 1
   # rx subcapture "sym"
-    set_addr $I10, rxcap_281_fail
-    rx277_cur."!mark_push"(0, rx277_pos, $I10)
+    set_addr $I10, rxcap_267_fail
+    rx263_cur."!mark_push"(0, rx263_pos, $I10)
   # rx literal  "0"
-    add $I11, rx277_pos, 1
-    gt $I11, rx277_eos, rx277_fail
-    sub $I11, rx277_pos, rx277_off
-    substr $S10, rx277_tgt, $I11, 1
-    ne $S10, "0", rx277_fail
-    add rx277_pos, 1
-    set_addr $I10, rxcap_281_fail
-    ($I12, $I11) = rx277_cur."!mark_peek"($I10)
-    rx277_cur."!cursor_pos"($I11)
-    ($P10) = rx277_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx277_pos, "")
-    rx277_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx263_pos, 1
+    gt $I11, rx263_eos, rx263_fail
+    sub $I11, rx263_pos, rx263_off
+    substr $S10, rx263_tgt, $I11, 1
+    ne $S10, "0", rx263_fail
+    add rx263_pos, 1
+    set_addr $I10, rxcap_267_fail
+    ($I12, $I11) = rx263_cur."!mark_peek"($I10)
+    rx263_cur."!cursor_pos"($I11)
+    ($P10) = rx263_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx263_pos, "")
+    rx263_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_281_done
-  rxcap_281_fail:
-    goto rx277_fail
-  rxcap_281_done:
+    goto rxcap_267_done
+  rxcap_267_fail:
+    goto rx263_fail
+  rxcap_267_done:
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx277_cur."!cursor_pos"(rx277_pos)
-    $P10 = rx277_cur."quotemod_check"("b")
-    unless $P10, rx277_fail
+    rx263_cur."!cursor_pos"(rx263_pos)
+    $P10 = rx263_cur."quotemod_check"("b")
+    unless $P10, rx263_fail
   # rx pass
-    rx277_cur."!cursor_pass"(rx277_pos, "quote_escape:sym<0>")
-    rx277_cur."!cursor_debug"("PASS  ", "quote_escape:sym<0>", " at pos=", rx277_pos)
-    .return (rx277_cur)
-  rx277_fail:
-.annotate 'line', 33
-    (rx277_rep, rx277_pos, $I10, $P10) = rx277_cur."!mark_fail"(0)
-    lt rx277_pos, -1, rx277_done
-    eq rx277_pos, -1, rx277_fail
+    rx263_cur."!cursor_pass"(rx263_pos, "quote_escape:sym<0>")
+    rx263_cur."!cursor_debug"("PASS  ", "quote_escape:sym<0>", " at pos=", rx263_pos)
+    .return (rx263_cur)
+  rx263_restart:
+.annotate 'line', 33
+    rx263_cur."!cursor_debug"("NEXT ", "quote_escape:sym<0>")
+  rx263_fail:
+    (rx263_rep, rx263_pos, $I10, $P10) = rx263_cur."!mark_fail"(0)
+    lt rx263_pos, -1, rx263_done
+    eq rx263_pos, -1, rx263_fail
     jump $I10
-  rx277_done:
-    rx277_cur."!cursor_fail"()
-    rx277_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<0>")
-    .return (rx277_cur)
+  rx263_done:
+    rx263_cur."!cursor_fail"()
+    rx263_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<0>")
+    .return (rx263_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<0>"  :subid("92_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<0>"  :subid("92_1279529214.68208") :method
 .annotate 'line', 33
-    new $P279, "ResizablePMCArray"
-    push $P279, "\\0"
-    .return ($P279)
+    new $P265, "ResizablePMCArray"
+    push $P265, "\\0"
+    .return ($P265)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "quote_escape:sym<misc>"  :subid("93_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "quote_escape:sym<misc>"  :subid("93_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .const 'Sub' $P302 = "97_1278500527.62277" 
-    capture_lex $P302
-    .const 'Sub' $P295 = "96_1278500527.62277" 
-    capture_lex $P295
-    .const 'Sub' $P290 = "95_1278500527.62277" 
-    capture_lex $P290
-    .local string rx283_tgt
-    .local int rx283_pos
-    .local int rx283_off
-    .local int rx283_eos
-    .local int rx283_rep
-    .local pmc rx283_cur
-    (rx283_cur, rx283_pos, rx283_tgt) = self."!cursor_start"()
-    rx283_cur."!cursor_debug"("START ", "quote_escape:sym<misc>")
-    .lex unicode:"$\x{a2}", rx283_cur
+    .const 'Sub' $P288 = "97_1279529214.68208" 
+    capture_lex $P288
+    .const 'Sub' $P281 = "96_1279529214.68208" 
+    capture_lex $P281
+    .const 'Sub' $P276 = "95_1279529214.68208" 
+    capture_lex $P276
+    .local string rx269_tgt
+    .local int rx269_pos
+    .local int rx269_off
+    .local int rx269_eos
+    .local int rx269_rep
+    .local pmc rx269_cur
+    (rx269_cur, rx269_pos, rx269_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx269_cur
     .local pmc match
     .lex "$/", match
-    length rx283_eos, rx283_tgt
-    gt rx283_pos, rx283_eos, rx283_done
-    set rx283_off, 0
-    lt rx283_pos, 2, rx283_start
-    sub rx283_off, rx283_pos, 1
-    substr rx283_tgt, rx283_tgt, rx283_off
-  rx283_start:
+    length rx269_eos, rx269_tgt
+    gt rx269_pos, rx269_eos, rx269_done
+    set rx269_off, 0
+    lt rx269_pos, 2, rx269_start
+    sub rx269_off, rx269_pos, 1
+    substr rx269_tgt, rx269_tgt, rx269_off
+  rx269_start:
+    eq $I10, 1, rx269_restart
+    rx269_cur."!cursor_debug"("START ", "quote_escape:sym<misc>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan286_done
-    goto rxscan286_scan
-  rxscan286_loop:
-    ($P10) = rx283_cur."from"()
+    ne $I10, -1, rxscan272_done
+    goto rxscan272_scan
+  rxscan272_loop:
+    ($P10) = rx269_cur."from"()
     inc $P10
-    set rx283_pos, $P10
-    ge rx283_pos, rx283_eos, rxscan286_done
-  rxscan286_scan:
-    set_addr $I10, rxscan286_loop
-    rx283_cur."!mark_push"(0, rx283_pos, $I10)
-  rxscan286_done:
+    set rx269_pos, $P10
+    ge rx269_pos, rx269_eos, rxscan272_done
+  rxscan272_scan:
+    set_addr $I10, rxscan272_loop
+    rx269_cur."!mark_push"(0, rx269_pos, $I10)
+  rxscan272_done:
 .annotate 'line', 100
-    rx283_cur."!cursor_pos"(rx283_pos)
-    find_lex $P287, unicode:"$\x{a2}"
-    $P288 = $P287."MATCH"()
-    store_lex "$/", $P288
-    .const 'Sub' $P290 = "95_1278500527.62277" 
-    capture_lex $P290
-    $P291 = $P290()
+    rx269_cur."!cursor_pos"(rx269_pos)
+    find_lex $P273, unicode:"$\x{a2}"
+    $P274 = $P273."MATCH"()
+    store_lex "$/", $P274
+    .const 'Sub' $P276 = "95_1279529214.68208" 
+    capture_lex $P276
+    $P277 = $P276()
   # rx literal  "\\"
-    add $I11, rx283_pos, 1
-    gt $I11, rx283_eos, rx283_fail
-    sub $I11, rx283_pos, rx283_off
-    substr $S10, rx283_tgt, $I11, 1
-    ne $S10, "\\", rx283_fail
-    add rx283_pos, 1
-  alt292_0:
+    add $I11, rx269_pos, 1
+    gt $I11, rx269_eos, rx269_fail
+    sub $I11, rx269_pos, rx269_off
+    substr $S10, rx269_tgt, $I11, 1
+    ne $S10, "\\", rx269_fail
+    add rx269_pos, 1
+  alt278_0:
 .annotate 'line', 101
-    set_addr $I10, alt292_1
-    rx283_cur."!mark_push"(0, rx283_pos, $I10)
+    set_addr $I10, alt278_1
+    rx269_cur."!mark_push"(0, rx269_pos, $I10)
 .annotate 'line', 102
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx283_cur."!cursor_pos"(rx283_pos)
-    $P10 = rx283_cur."quotemod_check"("b")
-    unless $P10, rx283_fail
-  alt293_0:
+    rx269_cur."!cursor_pos"(rx269_pos)
+    $P10 = rx269_cur."quotemod_check"("b")
+    unless $P10, rx269_fail
+  alt279_0:
 .annotate 'line', 103
-    set_addr $I10, alt293_1
-    rx283_cur."!mark_push"(0, rx283_pos, $I10)
+    set_addr $I10, alt279_1
+    rx269_cur."!mark_push"(0, rx269_pos, $I10)
 .annotate 'line', 104
-  # rx subrule $P295 subtype=capture negate=
-    rx283_cur."!cursor_pos"(rx283_pos)
-    .const 'Sub' $P295 = "96_1278500527.62277" 
-    capture_lex $P295
-    $P10 = rx283_cur.$P295()
-    unless $P10, rx283_fail
-    rx283_cur."!mark_push"(0, -1, 0, $P10)
+  # rx subrule $P281 subtype=capture negate=
+    rx269_cur."!cursor_pos"(rx269_pos)
+    .const 'Sub' $P281 = "96_1279529214.68208" 
+    capture_lex $P281
+    $P10 = rx269_cur.$P281()
+    unless $P10, rx269_fail
+    rx269_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("textqq")
-    rx283_pos = $P10."pos"()
-    goto alt293_end
-  alt293_1:
+    rx269_pos = $P10."pos"()
+    goto alt279_end
+  alt279_1:
 .annotate 'line', 105
   # rx subcapture "x"
-    set_addr $I10, rxcap_298_fail
-    rx283_cur."!mark_push"(0, rx283_pos, $I10)
+    set_addr $I10, rxcap_284_fail
+    rx269_cur."!mark_push"(0, rx269_pos, $I10)
   # rx charclass w
-    ge rx283_pos, rx283_eos, rx283_fail
-    sub $I10, rx283_pos, rx283_off
-    is_cclass $I11, 8192, rx283_tgt, $I10
-    unless $I11, rx283_fail
-    inc rx283_pos
-    set_addr $I10, rxcap_298_fail
-    ($I12, $I11) = rx283_cur."!mark_peek"($I10)
-    rx283_cur."!cursor_pos"($I11)
-    ($P10) = rx283_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx283_pos, "")
-    rx283_cur."!mark_push"(0, -1, 0, $P10)
+    ge rx269_pos, rx269_eos, rx269_fail
+    sub $I10, rx269_pos, rx269_off
+    is_cclass $I11, 8192, rx269_tgt, $I10
+    unless $I11, rx269_fail
+    inc rx269_pos
+    set_addr $I10, rxcap_284_fail
+    ($I12, $I11) = rx269_cur."!mark_peek"($I10)
+    rx269_cur."!cursor_pos"($I11)
+    ($P10) = rx269_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx269_pos, "")
+    rx269_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("x")
-    goto rxcap_298_done
-  rxcap_298_fail:
-    goto rx283_fail
-  rxcap_298_done:
-    rx283_cur."!cursor_pos"(rx283_pos)
-    find_lex $P299, unicode:"$\x{a2}"
-    $P300 = $P299."MATCH"()
-    store_lex "$/", $P300
-    .const 'Sub' $P302 = "97_1278500527.62277" 
-    capture_lex $P302
-    $P312 = $P302()
-  alt293_end:
+    goto rxcap_284_done
+  rxcap_284_fail:
+    goto rx269_fail
+  rxcap_284_done:
+    rx269_cur."!cursor_pos"(rx269_pos)
+    find_lex $P285, unicode:"$\x{a2}"
+    $P286 = $P285."MATCH"()
+    store_lex "$/", $P286
+    .const 'Sub' $P288 = "97_1279529214.68208" 
+    capture_lex $P288
+    $P298 = $P288()
+  alt279_end:
 .annotate 'line', 102
-    goto alt292_end
-  alt292_1:
+    goto alt278_end
+  alt278_1:
 .annotate 'line', 107
   # rx subcapture "textq"
-    set_addr $I10, rxcap_313_fail
-    rx283_cur."!mark_push"(0, rx283_pos, $I10)
+    set_addr $I10, rxcap_299_fail
+    rx269_cur."!mark_push"(0, rx269_pos, $I10)
   # rx charclass .
-    ge rx283_pos, rx283_eos, rx283_fail
-    inc rx283_pos
-    set_addr $I10, rxcap_313_fail
-    ($I12, $I11) = rx283_cur."!mark_peek"($I10)
-    rx283_cur."!cursor_pos"($I11)
-    ($P10) = rx283_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx283_pos, "")
-    rx283_cur."!mark_push"(0, -1, 0, $P10)
+    ge rx269_pos, rx269_eos, rx269_fail
+    inc rx269_pos
+    set_addr $I10, rxcap_299_fail
+    ($I12, $I11) = rx269_cur."!mark_peek"($I10)
+    rx269_cur."!cursor_pos"($I11)
+    ($P10) = rx269_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx269_pos, "")
+    rx269_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("textq")
-    goto rxcap_313_done
-  rxcap_313_fail:
-    goto rx283_fail
-  rxcap_313_done:
-  alt292_end:
+    goto rxcap_299_done
+  rxcap_299_fail:
+    goto rx269_fail
+  rxcap_299_done:
+  alt278_end:
 .annotate 'line', 99
   # rx pass
-    rx283_cur."!cursor_pass"(rx283_pos, "quote_escape:sym<misc>")
-    rx283_cur."!cursor_debug"("PASS  ", "quote_escape:sym<misc>", " at pos=", rx283_pos)
-    .return (rx283_cur)
-  rx283_fail:
-.annotate 'line', 33
-    (rx283_rep, rx283_pos, $I10, $P10) = rx283_cur."!mark_fail"(0)
-    lt rx283_pos, -1, rx283_done
-    eq rx283_pos, -1, rx283_fail
+    rx269_cur."!cursor_pass"(rx269_pos, "quote_escape:sym<misc>")
+    rx269_cur."!cursor_debug"("PASS  ", "quote_escape:sym<misc>", " at pos=", rx269_pos)
+    .return (rx269_cur)
+  rx269_restart:
+.annotate 'line', 33
+    rx269_cur."!cursor_debug"("NEXT ", "quote_escape:sym<misc>")
+  rx269_fail:
+    (rx269_rep, rx269_pos, $I10, $P10) = rx269_cur."!mark_fail"(0)
+    lt rx269_pos, -1, rx269_done
+    eq rx269_pos, -1, rx269_fail
     jump $I10
-  rx283_done:
-    rx283_cur."!cursor_fail"()
-    rx283_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<misc>")
-    .return (rx283_cur)
+  rx269_done:
+    rx269_cur."!cursor_fail"()
+    rx269_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<misc>")
+    .return (rx269_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<misc>"  :subid("94_1278500527.62277") :method
+.sub "!PREFIX__quote_escape:sym<misc>"  :subid("94_1279529214.68208") :method
 .annotate 'line', 33
-    new $P285, "ResizablePMCArray"
-    push $P285, ""
-    .return ($P285)
+    new $P271, "ResizablePMCArray"
+    push $P271, ""
+    .return ($P271)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "_block289"  :anon :subid("95_1278500527.62277") :outer("93_1278500527.62277")
+.sub "_block275"  :anon :subid("95_1279529214.68208") :outer("93_1279529214.68208")
 .annotate 'line', 100
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "_block294"  :anon :subid("96_1278500527.62277") :method :outer("93_1278500527.62277")
+.sub "_block280"  :anon :subid("96_1279529214.68208") :method :outer("93_1279529214.68208")
 .annotate 'line', 104
-    .local string rx296_tgt
-    .local int rx296_pos
-    .local int rx296_off
-    .local int rx296_eos
-    .local int rx296_rep
-    .local pmc rx296_cur
-    (rx296_cur, rx296_pos, rx296_tgt) = self."!cursor_start"()
-    rx296_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx296_cur
+    .local string rx282_tgt
+    .local int rx282_pos
+    .local int rx282_off
+    .local int rx282_eos
+    .local int rx282_rep
+    .local pmc rx282_cur
+    (rx282_cur, rx282_pos, rx282_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx282_cur
     .local pmc match
     .lex "$/", match
-    length rx296_eos, rx296_tgt
-    gt rx296_pos, rx296_eos, rx296_done
-    set rx296_off, 0
-    lt rx296_pos, 2, rx296_start
-    sub rx296_off, rx296_pos, 1
-    substr rx296_tgt, rx296_tgt, rx296_off
-  rx296_start:
+    length rx282_eos, rx282_tgt
+    gt rx282_pos, rx282_eos, rx282_done
+    set rx282_off, 0
+    lt rx282_pos, 2, rx282_start
+    sub rx282_off, rx282_pos, 1
+    substr rx282_tgt, rx282_tgt, rx282_off
+  rx282_start:
+    eq $I10, 1, rx282_restart
+    rx282_cur."!cursor_debug"("START ", "")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan297_done
-    goto rxscan297_scan
-  rxscan297_loop:
-    ($P10) = rx296_cur."from"()
+    ne $I10, -1, rxscan283_done
+    goto rxscan283_scan
+  rxscan283_loop:
+    ($P10) = rx282_cur."from"()
     inc $P10
-    set rx296_pos, $P10
-    ge rx296_pos, rx296_eos, rxscan297_done
-  rxscan297_scan:
-    set_addr $I10, rxscan297_loop
-    rx296_cur."!mark_push"(0, rx296_pos, $I10)
-  rxscan297_done:
+    set rx282_pos, $P10
+    ge rx282_pos, rx282_eos, rxscan283_done
+  rxscan283_scan:
+    set_addr $I10, rxscan283_loop
+    rx282_cur."!mark_push"(0, rx282_pos, $I10)
+  rxscan283_done:
   # rx charclass W
-    ge rx296_pos, rx296_eos, rx296_fail
-    sub $I10, rx296_pos, rx296_off
-    is_cclass $I11, 8192, rx296_tgt, $I10
-    if $I11, rx296_fail
-    inc rx296_pos
+    ge rx282_pos, rx282_eos, rx282_fail
+    sub $I10, rx282_pos, rx282_off
+    is_cclass $I11, 8192, rx282_tgt, $I10
+    if $I11, rx282_fail
+    inc rx282_pos
   # rx pass
-    rx296_cur."!cursor_pass"(rx296_pos, "")
-    rx296_cur."!cursor_debug"("PASS  ", "", " at pos=", rx296_pos)
-    .return (rx296_cur)
-  rx296_fail:
-    (rx296_rep, rx296_pos, $I10, $P10) = rx296_cur."!mark_fail"(0)
-    lt rx296_pos, -1, rx296_done
-    eq rx296_pos, -1, rx296_fail
+    rx282_cur."!cursor_pass"(rx282_pos, "")
+    rx282_cur."!cursor_debug"("PASS  ", "", " at pos=", rx282_pos)
+    .return (rx282_cur)
+  rx282_restart:
+    rx282_cur."!cursor_debug"("NEXT ", "")
+  rx282_fail:
+    (rx282_rep, rx282_pos, $I10, $P10) = rx282_cur."!mark_fail"(0)
+    lt rx282_pos, -1, rx282_done
+    eq rx282_pos, -1, rx282_fail
     jump $I10
-  rx296_done:
-    rx296_cur."!cursor_fail"()
-    rx296_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx296_cur)
+  rx282_done:
+    rx282_cur."!cursor_fail"()
+    rx282_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx282_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "_block301"  :anon :subid("97_1278500527.62277") :outer("93_1278500527.62277")
+.sub "_block287"  :anon :subid("97_1279529214.68208") :outer("93_1279529214.68208")
 .annotate 'line', 105
-    find_lex $P303, "$/"
-    $P304 = $P303."CURSOR"()
-    new $P305, "String"
-    assign $P305, "Unrecognized backslash sequence: '\\"
-    find_lex $P306, "$/"
-    unless_null $P306, vivify_108
-    $P306 = root_new ['parrot';'Hash']
+    find_lex $P289, "$/"
+    $P290 = $P289."CURSOR"()
+    new $P291, "String"
+    assign $P291, "Unrecognized backslash sequence: '\\"
+    find_lex $P292, "$/"
+    unless_null $P292, vivify_108
+    $P292 = root_new ['parrot';'Hash']
   vivify_108:
-    set $P307, $P306["x"]
-    unless_null $P307, vivify_109
-    new $P307, "Undef"
+    set $P293, $P292["x"]
+    unless_null $P293, vivify_109
+    new $P293, "Undef"
   vivify_109:
-    $S308 = $P307."Str"()
-    concat $P309, $P305, $S308
-    concat $P310, $P309, "'"
-    $P311 = $P304."panic"($P310)
-    .return ($P311)
+    $S294 = $P293."Str"()
+    concat $P295, $P291, $S294
+    concat $P296, $P295, "'"
+    $P297 = $P290."panic"($P296)
+    .return ($P297)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "charname"  :subid("98_1278500527.62277") :method :outer("11_1278500527.62277")
-.annotate 'line', 33
-    .const 'Sub' $P324 = "100_1278500527.62277" 
-    capture_lex $P324
-    .local string rx315_tgt
-    .local int rx315_pos
-    .local int rx315_off
-    .local int rx315_eos
-    .local int rx315_rep
-    .local pmc rx315_cur
-    (rx315_cur, rx315_pos, rx315_tgt) = self."!cursor_start"()
-    rx315_cur."!cursor_debug"("START ", "charname")
-    .lex unicode:"$\x{a2}", rx315_cur
+.sub "charname"  :subid("98_1279529214.68208") :method :outer("11_1279529214.68208")
+.annotate 'line', 33
+    .const 'Sub' $P310 = "100_1279529214.68208" 
+    capture_lex $P310
+    .local string rx301_tgt
+    .local int rx301_pos
+    .local int rx301_off
+    .local int rx301_eos
+    .local int rx301_rep
+    .local pmc rx301_cur
+    (rx301_cur, rx301_pos, rx301_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx301_cur
     .local pmc match
     .lex "$/", match
-    length rx315_eos, rx315_tgt
-    gt rx315_pos, rx315_eos, rx315_done
-    set rx315_off, 0
-    lt rx315_pos, 2, rx315_start
-    sub rx315_off, rx315_pos, 1
-    substr rx315_tgt, rx315_tgt, rx315_off
-  rx315_start:
+    length rx301_eos, rx301_tgt
+    gt rx301_pos, rx301_eos, rx301_done
+    set rx301_off, 0
+    lt rx301_pos, 2, rx301_start
+    sub rx301_off, rx301_pos, 1
+    substr rx301_tgt, rx301_tgt, rx301_off
+  rx301_start:
+    eq $I10, 1, rx301_restart
+    rx301_cur."!cursor_debug"("START ", "charname")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan319_done
-    goto rxscan319_scan
-  rxscan319_loop:
-    ($P10) = rx315_cur."from"()
+    ne $I10, -1, rxscan305_done
+    goto rxscan305_scan
+  rxscan305_loop:
+    ($P10) = rx301_cur."from"()
     inc $P10
-    set rx315_pos, $P10
-    ge rx315_pos, rx315_eos, rxscan319_done
-  rxscan319_scan:
-    set_addr $I10, rxscan319_loop
-    rx315_cur."!mark_push"(0, rx315_pos, $I10)
-  rxscan319_done:
-  alt320_0:
+    set rx301_pos, $P10
+    ge rx301_pos, rx301_eos, rxscan305_done
+  rxscan305_scan:
+    set_addr $I10, rxscan305_loop
+    rx301_cur."!mark_push"(0, rx301_pos, $I10)
+  rxscan305_done:
+  alt306_0:
 .annotate 'line', 111
-    set_addr $I10, alt320_1
-    rx315_cur."!mark_push"(0, rx315_pos, $I10)
+    set_addr $I10, alt306_1
+    rx301_cur."!mark_push"(0, rx301_pos, $I10)
 .annotate 'line', 112
   # rx subrule "integer" subtype=capture negate=
-    rx315_cur."!cursor_pos"(rx315_pos)
-    $P10 = rx315_cur."integer"()
-    unless $P10, rx315_fail
-    rx315_cur."!mark_push"(0, -1, 0, $P10)
+    rx301_cur."!cursor_pos"(rx301_pos)
+    $P10 = rx301_cur."integer"()
+    unless $P10, rx301_fail
+    rx301_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("integer")
-    rx315_pos = $P10."pos"()
-    goto alt320_end
-  alt320_1:
+    rx301_pos = $P10."pos"()
+    goto alt306_end
+  alt306_1:
 .annotate 'line', 113
   # rx enumcharlist negate=0 
-    ge rx315_pos, rx315_eos, rx315_fail
-    sub $I10, rx315_pos, rx315_off
-    substr $S10, rx315_tgt, $I10, 1
+    ge rx301_pos, rx301_eos, rx301_fail
+    sub $I10, rx301_pos, rx301_off
+    substr $S10, rx301_tgt, $I10, 1
     index $I11, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", $S10
-    lt $I11, 0, rx315_fail
-    inc rx315_pos
-  # rx rxquantf321 ** 0..*
-    set_addr $I10, rxquantf321_loop
-    rx315_cur."!mark_push"(0, rx315_pos, $I10)
-    goto rxquantf321_done
-  rxquantf321_loop:
+    lt $I11, 0, rx301_fail
+    inc rx301_pos
+  # rx rxquantf307 ** 0..*
+    set_addr $I10, rxquantf307_loop
+    rx301_cur."!mark_push"(0, rx301_pos, $I10)
+    goto rxquantf307_done
+  rxquantf307_loop:
   # rx enumcharlist negate=1 
-    ge rx315_pos, rx315_eos, rx315_fail
-    sub $I10, rx315_pos, rx315_off
-    substr $S10, rx315_tgt, $I10, 1
+    ge rx301_pos, rx301_eos, rx301_fail
+    sub $I10, rx301_pos, rx301_off
+    substr $S10, rx301_tgt, $I10, 1
     index $I11, "],#", $S10
-    ge $I11, 0, rx315_fail
-    inc rx315_pos
-    set_addr $I10, rxquantf321_loop
-    rx315_cur."!mark_push"($I322, rx315_pos, $I10)
-  rxquantf321_done:
+    ge $I11, 0, rx301_fail
+    inc rx301_pos
+    set_addr $I10, rxquantf307_loop
+    rx301_cur."!mark_push"(rx301_rep, rx301_pos, $I10)
+  rxquantf307_done:
   # rx enumcharlist negate=0 
-    ge rx315_pos, rx315_eos, rx315_fail
-    sub $I10, rx315_pos, rx315_off
-    substr $S10, rx315_tgt, $I10, 1
+    ge rx301_pos, rx301_eos, rx301_fail
+    sub $I10, rx301_pos, rx301_off
+    substr $S10, rx301_tgt, $I10, 1
     index $I11, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)", $S10
-    lt $I11, 0, rx315_fail
-    inc rx315_pos
+    lt $I11, 0, rx301_fail
+    inc rx301_pos
 .annotate 'line', 114
   # rx subrule "before" subtype=zerowidth negate=
-    rx315_cur."!cursor_pos"(rx315_pos)
-    .const 'Sub' $P324 = "100_1278500527.62277" 
-    capture_lex $P324
-    $P10 = rx315_cur."before"($P324)
-    unless $P10, rx315_fail
-  alt320_end:
+    rx301_cur."!cursor_pos"(rx301_pos)
+    .const 'Sub' $P310 = "100_1279529214.68208" 
+    capture_lex $P310
+    $P10 = rx301_cur."before"($P310)
+    unless $P10, rx301_fail
+  alt306_end:
 .annotate 'line', 111
   # rx pass
-    rx315_cur."!cursor_pass"(rx315_pos, "charname")
-    rx315_cur."!cursor_debug"("PASS  ", "charname", " at pos=", rx315_pos)
-    .return (rx315_cur)
-  rx315_fail:
-.annotate 'line', 33
-    (rx315_rep, rx315_pos, $I10, $P10) = rx315_cur."!mark_fail"(0)
-    lt rx315_pos, -1, rx315_done
-    eq rx315_pos, -1, rx315_fail
+    rx301_cur."!cursor_pass"(rx301_pos, "charname")
+    rx301_cur."!cursor_debug"("PASS  ", "charname", " at pos=", rx301_pos)
+    .return (rx301_cur)
+  rx301_restart:
+.annotate 'line', 33
+    rx301_cur."!cursor_debug"("NEXT ", "charname")
+  rx301_fail:
+    (rx301_rep, rx301_pos, $I10, $P10) = rx301_cur."!mark_fail"(0)
+    lt rx301_pos, -1, rx301_done
+    eq rx301_pos, -1, rx301_fail
     jump $I10
-  rx315_done:
-    rx315_cur."!cursor_fail"()
-    rx315_cur."!cursor_debug"("FAIL  ", "charname")
-    .return (rx315_cur)
+  rx301_done:
+    rx301_cur."!cursor_fail"()
+    rx301_cur."!cursor_debug"("FAIL  ", "charname")
+    .return (rx301_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__charname"  :subid("99_1278500527.62277") :method
-.annotate 'line', 33
-    $P317 = self."!PREFIX__!subrule"("integer", "")
-    new $P318, "ResizablePMCArray"
-    push $P318, "Z"
-    push $P318, "Y"
-    push $P318, "X"
-    push $P318, "W"
-    push $P318, "V"
-    push $P318, "U"
-    push $P318, "T"
-    push $P318, "S"
-    push $P318, "R"
-    push $P318, "Q"
-    push $P318, "P"
-    push $P318, "O"
-    push $P318, "N"
-    push $P318, "M"
-    push $P318, "L"
-    push $P318, "K"
-    push $P318, "J"
-    push $P318, "I"
-    push $P318, "H"
-    push $P318, "G"
-    push $P318, "F"
-    push $P318, "E"
-    push $P318, "D"
-    push $P318, "C"
-    push $P318, "B"
-    push $P318, "A"
-    push $P318, "z"
-    push $P318, "y"
-    push $P318, "x"
-    push $P318, "w"
-    push $P318, "v"
-    push $P318, "u"
-    push $P318, "t"
-    push $P318, "s"
-    push $P318, "r"
-    push $P318, "q"
-    push $P318, "p"
-    push $P318, "o"
-    push $P318, "n"
-    push $P318, "m"
-    push $P318, "l"
-    push $P318, "k"
-    push $P318, "j"
-    push $P318, "i"
-    push $P318, "h"
-    push $P318, "g"
-    push $P318, "f"
-    push $P318, "e"
-    push $P318, "d"
-    push $P318, "c"
-    push $P318, "b"
-    push $P318, "a"
-    push $P318, $P317
-    .return ($P318)
+.sub "!PREFIX__charname"  :subid("99_1279529214.68208") :method
+.annotate 'line', 33
+    $P303 = self."!PREFIX__!subrule"("integer", "")
+    new $P304, "ResizablePMCArray"
+    push $P304, "Z"
+    push $P304, "Y"
+    push $P304, "X"
+    push $P304, "W"
+    push $P304, "V"
+    push $P304, "U"
+    push $P304, "T"
+    push $P304, "S"
+    push $P304, "R"
+    push $P304, "Q"
+    push $P304, "P"
+    push $P304, "O"
+    push $P304, "N"
+    push $P304, "M"
+    push $P304, "L"
+    push $P304, "K"
+    push $P304, "J"
+    push $P304, "I"
+    push $P304, "H"
+    push $P304, "G"
+    push $P304, "F"
+    push $P304, "E"
+    push $P304, "D"
+    push $P304, "C"
+    push $P304, "B"
+    push $P304, "A"
+    push $P304, "z"
+    push $P304, "y"
+    push $P304, "x"
+    push $P304, "w"
+    push $P304, "v"
+    push $P304, "u"
+    push $P304, "t"
+    push $P304, "s"
+    push $P304, "r"
+    push $P304, "q"
+    push $P304, "p"
+    push $P304, "o"
+    push $P304, "n"
+    push $P304, "m"
+    push $P304, "l"
+    push $P304, "k"
+    push $P304, "j"
+    push $P304, "i"
+    push $P304, "h"
+    push $P304, "g"
+    push $P304, "f"
+    push $P304, "e"
+    push $P304, "d"
+    push $P304, "c"
+    push $P304, "b"
+    push $P304, "a"
+    push $P304, $P303
+    .return ($P304)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "_block323"  :anon :subid("100_1278500527.62277") :method :outer("98_1278500527.62277")
+.sub "_block309"  :anon :subid("100_1279529214.68208") :method :outer("98_1279529214.68208")
 .annotate 'line', 114
-    .local string rx325_tgt
-    .local int rx325_pos
-    .local int rx325_off
-    .local int rx325_eos
-    .local int rx325_rep
-    .local pmc rx325_cur
-    (rx325_cur, rx325_pos, rx325_tgt) = self."!cursor_start"()
-    rx325_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx325_cur
+    .local string rx311_tgt
+    .local int rx311_pos
+    .local int rx311_off
+    .local int rx311_eos
+    .local int rx311_rep
+    .local pmc rx311_cur
+    (rx311_cur, rx311_pos, rx311_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx311_cur
     .local pmc match
     .lex "$/", match
-    length rx325_eos, rx325_tgt
-    gt rx325_pos, rx325_eos, rx325_done
-    set rx325_off, 0
-    lt rx325_pos, 2, rx325_start
-    sub rx325_off, rx325_pos, 1
-    substr rx325_tgt, rx325_tgt, rx325_off
-  rx325_start:
+    length rx311_eos, rx311_tgt
+    gt rx311_pos, rx311_eos, rx311_done
+    set rx311_off, 0
+    lt rx311_pos, 2, rx311_start
+    sub rx311_off, rx311_pos, 1
+    substr rx311_tgt, rx311_tgt, rx311_off
+  rx311_start:
+    eq $I10, 1, rx311_restart
+    rx311_cur."!cursor_debug"("START ", "")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan326_done
-    goto rxscan326_scan
-  rxscan326_loop:
-    ($P10) = rx325_cur."from"()
+    ne $I10, -1, rxscan312_done
+    goto rxscan312_scan
+  rxscan312_loop:
+    ($P10) = rx311_cur."from"()
     inc $P10
-    set rx325_pos, $P10
-    ge rx325_pos, rx325_eos, rxscan326_done
-  rxscan326_scan:
-    set_addr $I10, rxscan326_loop
-    rx325_cur."!mark_push"(0, rx325_pos, $I10)
-  rxscan326_done:
+    set rx311_pos, $P10
+    ge rx311_pos, rx311_eos, rxscan312_done
+  rxscan312_scan:
+    set_addr $I10, rxscan312_loop
+    rx311_cur."!mark_push"(0, rx311_pos, $I10)
+  rxscan312_done:
   # rx charclass_q s r 0..-1
-    sub $I10, rx325_pos, rx325_off
-    find_not_cclass $I11, 32, rx325_tgt, $I10, rx325_eos
-    add rx325_pos, rx325_off, $I11
+    sub $I10, rx311_pos, rx311_off
+    find_not_cclass $I11, 32, rx311_tgt, $I10, rx311_eos
+    add rx311_pos, rx311_off, $I11
   # rx enumcharlist negate=0 
-    ge rx325_pos, rx325_eos, rx325_fail
-    sub $I10, rx325_pos, rx325_off
-    substr $S10, rx325_tgt, $I10, 1
+    ge rx311_pos, rx311_eos, rx311_fail
+    sub $I10, rx311_pos, rx311_off
+    substr $S10, rx311_tgt, $I10, 1
     index $I11, "],#", $S10
-    lt $I11, 0, rx325_fail
-    inc rx325_pos
+    lt $I11, 0, rx311_fail
+    inc rx311_pos
   # rx pass
-    rx325_cur."!cursor_pass"(rx325_pos, "")
-    rx325_cur."!cursor_debug"("PASS  ", "", " at pos=", rx325_pos)
-    .return (rx325_cur)
-  rx325_fail:
-    (rx325_rep, rx325_pos, $I10, $P10) = rx325_cur."!mark_fail"(0)
-    lt rx325_pos, -1, rx325_done
-    eq rx325_pos, -1, rx325_fail
+    rx311_cur."!cursor_pass"(rx311_pos, "")
+    rx311_cur."!cursor_debug"("PASS  ", "", " at pos=", rx311_pos)
+    .return (rx311_cur)
+  rx311_restart:
+    rx311_cur."!cursor_debug"("NEXT ", "")
+  rx311_fail:
+    (rx311_rep, rx311_pos, $I10, $P10) = rx311_cur."!mark_fail"(0)
+    lt rx311_pos, -1, rx311_done
+    eq rx311_pos, -1, rx311_fail
     jump $I10
-  rx325_done:
-    rx325_cur."!cursor_fail"()
-    rx325_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx325_cur)
+  rx311_done:
+    rx311_cur."!cursor_fail"()
+    rx311_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx311_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "charnames"  :subid("101_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "charnames"  :subid("101_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx328_tgt
-    .local int rx328_pos
-    .local int rx328_off
-    .local int rx328_eos
-    .local int rx328_rep
-    .local pmc rx328_cur
-    (rx328_cur, rx328_pos, rx328_tgt) = self."!cursor_start"()
-    rx328_cur."!cursor_debug"("START ", "charnames")
-    rx328_cur."!cursor_caparray"("charname")
-    .lex unicode:"$\x{a2}", rx328_cur
+    .local string rx314_tgt
+    .local int rx314_pos
+    .local int rx314_off
+    .local int rx314_eos
+    .local int rx314_rep
+    .local pmc rx314_cur
+    (rx314_cur, rx314_pos, rx314_tgt, $I10) = self."!cursor_start"()
+    rx314_cur."!cursor_caparray"("charname")
+    .lex unicode:"$\x{a2}", rx314_cur
     .local pmc match
     .lex "$/", match
-    length rx328_eos, rx328_tgt
-    gt rx328_pos, rx328_eos, rx328_done
-    set rx328_off, 0
-    lt rx328_pos, 2, rx328_start
-    sub rx328_off, rx328_pos, 1
-    substr rx328_tgt, rx328_tgt, rx328_off
-  rx328_start:
+    length rx314_eos, rx314_tgt
+    gt rx314_pos, rx314_eos, rx314_done
+    set rx314_off, 0
+    lt rx314_pos, 2, rx314_start
+    sub rx314_off, rx314_pos, 1
+    substr rx314_tgt, rx314_tgt, rx314_off
+  rx314_start:
+    eq $I10, 1, rx314_restart
+    rx314_cur."!cursor_debug"("START ", "charnames")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan331_done
-    goto rxscan331_scan
-  rxscan331_loop:
-    ($P10) = rx328_cur."from"()
+    ne $I10, -1, rxscan317_done
+    goto rxscan317_scan
+  rxscan317_loop:
+    ($P10) = rx314_cur."from"()
     inc $P10
-    set rx328_pos, $P10
-    ge rx328_pos, rx328_eos, rxscan331_done
-  rxscan331_scan:
-    set_addr $I10, rxscan331_loop
-    rx328_cur."!mark_push"(0, rx328_pos, $I10)
-  rxscan331_done:
+    set rx314_pos, $P10
+    ge rx314_pos, rx314_eos, rxscan317_done
+  rxscan317_scan:
+    set_addr $I10, rxscan317_loop
+    rx314_cur."!mark_push"(0, rx314_pos, $I10)
+  rxscan317_done:
 .annotate 'line', 116
-  # rx rxquantr332 ** 1..*
-    set_addr $I333, rxquantr332_done
-    rx328_cur."!mark_push"(0, -1, $I333)
-  rxquantr332_loop:
+  # rx rxquantr318 ** 1..*
+    set_addr $I10, rxquantr318_done
+    rx314_cur."!mark_push"(0, -1, $I10)
+  rxquantr318_loop:
   # rx subrule "ws" subtype=method negate=
-    rx328_cur."!cursor_pos"(rx328_pos)
-    $P10 = rx328_cur."ws"()
-    unless $P10, rx328_fail
-    rx328_pos = $P10."pos"()
+    rx314_cur."!cursor_pos"(rx314_pos)
+    $P10 = rx314_cur."ws"()
+    unless $P10, rx314_fail
+    rx314_pos = $P10."pos"()
   # rx subrule "charname" subtype=capture negate=
-    rx328_cur."!cursor_pos"(rx328_pos)
-    $P10 = rx328_cur."charname"()
-    unless $P10, rx328_fail
-    rx328_cur."!mark_push"(0, -1, 0, $P10)
+    rx314_cur."!cursor_pos"(rx314_pos)
+    $P10 = rx314_cur."charname"()
+    unless $P10, rx314_fail
+    rx314_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("charname")
-    rx328_pos = $P10."pos"()
+    rx314_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx328_cur."!cursor_pos"(rx328_pos)
-    $P10 = rx328_cur."ws"()
-    unless $P10, rx328_fail
-    rx328_pos = $P10."pos"()
-    (rx328_rep) = rx328_cur."!mark_commit"($I333)
-    rx328_cur."!mark_push"(rx328_rep, rx328_pos, $I333)
+    rx314_cur."!cursor_pos"(rx314_pos)
+    $P10 = rx314_cur."ws"()
+    unless $P10, rx314_fail
+    rx314_pos = $P10."pos"()
+    set_addr $I10, rxquantr318_done
+    (rx314_rep) = rx314_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr318_done
+    rx314_cur."!mark_push"(rx314_rep, rx314_pos, $I10)
   # rx literal  ","
-    add $I11, rx328_pos, 1
-    gt $I11, rx328_eos, rx328_fail
-    sub $I11, rx328_pos, rx328_off
-    substr $S10, rx328_tgt, $I11, 1
-    ne $S10, ",", rx328_fail
-    add rx328_pos, 1
-    goto rxquantr332_loop
-  rxquantr332_done:
+    add $I11, rx314_pos, 1
+    gt $I11, rx314_eos, rx314_fail
+    sub $I11, rx314_pos, rx314_off
+    substr $S10, rx314_tgt, $I11, 1
+    ne $S10, ",", rx314_fail
+    add rx314_pos, 1
+    goto rxquantr318_loop
+  rxquantr318_done:
   # rx pass
-    rx328_cur."!cursor_pass"(rx328_pos, "charnames")
-    rx328_cur."!cursor_debug"("PASS  ", "charnames", " at pos=", rx328_pos)
-    .return (rx328_cur)
-  rx328_fail:
-.annotate 'line', 33
-    (rx328_rep, rx328_pos, $I10, $P10) = rx328_cur."!mark_fail"(0)
-    lt rx328_pos, -1, rx328_done
-    eq rx328_pos, -1, rx328_fail
+    rx314_cur."!cursor_pass"(rx314_pos, "charnames")
+    rx314_cur."!cursor_debug"("PASS  ", "charnames", " at pos=", rx314_pos)
+    .return (rx314_cur)
+  rx314_restart:
+.annotate 'line', 33
+    rx314_cur."!cursor_debug"("NEXT ", "charnames")
+  rx314_fail:
+    (rx314_rep, rx314_pos, $I10, $P10) = rx314_cur."!mark_fail"(0)
+    lt rx314_pos, -1, rx314_done
+    eq rx314_pos, -1, rx314_fail
     jump $I10
-  rx328_done:
-    rx328_cur."!cursor_fail"()
-    rx328_cur."!cursor_debug"("FAIL  ", "charnames")
-    .return (rx328_cur)
+  rx314_done:
+    rx314_cur."!cursor_fail"()
+    rx314_cur."!cursor_debug"("FAIL  ", "charnames")
+    .return (rx314_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__charnames"  :subid("102_1278500527.62277") :method
+.sub "!PREFIX__charnames"  :subid("102_1279529214.68208") :method
 .annotate 'line', 33
-    new $P330, "ResizablePMCArray"
-    push $P330, ""
-    .return ($P330)
+    new $P316, "ResizablePMCArray"
+    push $P316, ""
+    .return ($P316)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "charspec"  :subid("103_1278500527.62277") :method :outer("11_1278500527.62277")
+.sub "charspec"  :subid("103_1279529214.68208") :method :outer("11_1279529214.68208")
 .annotate 'line', 33
-    .local string rx335_tgt
-    .local int rx335_pos
-    .local int rx335_off
-    .local int rx335_eos
-    .local int rx335_rep
-    .local pmc rx335_cur
-    (rx335_cur, rx335_pos, rx335_tgt) = self."!cursor_start"()
-    rx335_cur."!cursor_debug"("START ", "charspec")
-    .lex unicode:"$\x{a2}", rx335_cur
+    .local string rx320_tgt
+    .local int rx320_pos
+    .local int rx320_off
+    .local int rx320_eos
+    .local int rx320_rep
+    .local pmc rx320_cur
+    (rx320_cur, rx320_pos, rx320_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx320_cur
     .local pmc match
     .lex "$/", match
-    length rx335_eos, rx335_tgt
-    gt rx335_pos, rx335_eos, rx335_done
-    set rx335_off, 0
-    lt rx335_pos, 2, rx335_start
-    sub rx335_off, rx335_pos, 1
-    substr rx335_tgt, rx335_tgt, rx335_off
-  rx335_start:
+    length rx320_eos, rx320_tgt
+    gt rx320_pos, rx320_eos, rx320_done
+    set rx320_off, 0
+    lt rx320_pos, 2, rx320_start
+    sub rx320_off, rx320_pos, 1
+    substr rx320_tgt, rx320_tgt, rx320_off
+  rx320_start:
+    eq $I10, 1, rx320_restart
+    rx320_cur."!cursor_debug"("START ", "charspec")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan340_done
-    goto rxscan340_scan
-  rxscan340_loop:
-    ($P10) = rx335_cur."from"()
+    ne $I10, -1, rxscan325_done
+    goto rxscan325_scan
+  rxscan325_loop:
+    ($P10) = rx320_cur."from"()
     inc $P10
-    set rx335_pos, $P10
-    ge rx335_pos, rx335_eos, rxscan340_done
-  rxscan340_scan:
-    set_addr $I10, rxscan340_loop
-    rx335_cur."!mark_push"(0, rx335_pos, $I10)
-  rxscan340_done:
-  alt341_0:
+    set rx320_pos, $P10
+    ge rx320_pos, rx320_eos, rxscan325_done
+  rxscan325_scan:
+    set_addr $I10, rxscan325_loop
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
+  rxscan325_done:
+  alt326_0:
 .annotate 'line', 118
-    set_addr $I10, alt341_1
-    rx335_cur."!mark_push"(0, rx335_pos, $I10)
+    set_addr $I10, alt326_1
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
 .annotate 'line', 119
   # rx literal  "["
-    add $I11, rx335_pos, 1
-    gt $I11, rx335_eos, rx335_fail
-    sub $I11, rx335_pos, rx335_off
-    substr $S10, rx335_tgt, $I11, 1
-    ne $S10, "[", rx335_fail
-    add rx335_pos, 1
+    add $I11, rx320_pos, 1
+    gt $I11, rx320_eos, rx320_fail
+    sub $I11, rx320_pos, rx320_off
+    substr $S10, rx320_tgt, $I11, 1
+    ne $S10, "[", rx320_fail
+    add rx320_pos, 1
   # rx subrule "charnames" subtype=capture negate=
-    rx335_cur."!cursor_pos"(rx335_pos)
-    $P10 = rx335_cur."charnames"()
-    unless $P10, rx335_fail
-    rx335_cur."!mark_push"(0, -1, 0, $P10)
+    rx320_cur."!cursor_pos"(rx320_pos)
+    $P10 = rx320_cur."charnames"()
+    unless $P10, rx320_fail
+    rx320_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("charnames")
-    rx335_pos = $P10."pos"()
+    rx320_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx335_pos, 1
-    gt $I11, rx335_eos, rx335_fail
-    sub $I11, rx335_pos, rx335_off
-    substr $S10, rx335_tgt, $I11, 1
-    ne $S10, "]", rx335_fail
-    add rx335_pos, 1
-    goto alt341_end
-  alt341_1:
-    set_addr $I10, alt341_2
-    rx335_cur."!mark_push"(0, rx335_pos, $I10)
+    add $I11, rx320_pos, 1
+    gt $I11, rx320_eos, rx320_fail
+    sub $I11, rx320_pos, rx320_off
+    substr $S10, rx320_tgt, $I11, 1
+    ne $S10, "]", rx320_fail
+    add rx320_pos, 1
+    goto alt326_end
+  alt326_1:
+    set_addr $I10, alt326_2
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
 .annotate 'line', 120
   # rx charclass_q d r 1..-1
-    sub $I10, rx335_pos, rx335_off
-    find_not_cclass $I11, 8, rx335_tgt, $I10, rx335_eos
+    sub $I10, rx320_pos, rx320_off
+    find_not_cclass $I11, 8, rx320_tgt, $I10, rx320_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx335_fail
-    add rx335_pos, rx335_off, $I11
-  # rx rxquantr342 ** 0..*
-    set_addr $I343, rxquantr342_done
-    rx335_cur."!mark_push"(0, rx335_pos, $I343)
-  rxquantr342_loop:
+    lt $I11, $I12, rx320_fail
+    add rx320_pos, rx320_off, $I11
+  # rx rxquantr327 ** 0..*
+    set_addr $I10, rxquantr327_done
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
+  rxquantr327_loop:
   # rx literal  "_"
-    add $I11, rx335_pos, 1
-    gt $I11, rx335_eos, rx335_fail
-    sub $I11, rx335_pos, rx335_off
-    substr $S10, rx335_tgt, $I11, 1
-    ne $S10, "_", rx335_fail
-    add rx335_pos, 1
+    add $I11, rx320_pos, 1
+    gt $I11, rx320_eos, rx320_fail
+    sub $I11, rx320_pos, rx320_off
+    substr $S10, rx320_tgt, $I11, 1
+    ne $S10, "_", rx320_fail
+    add rx320_pos, 1
   # rx charclass_q d r 1..-1
-    sub $I10, rx335_pos, rx335_off
-    find_not_cclass $I11, 8, rx335_tgt, $I10, rx335_eos
+    sub $I10, rx320_pos, rx320_off
+    find_not_cclass $I11, 8, rx320_tgt, $I10, rx320_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx335_fail
-    add rx335_pos, rx335_off, $I11
-    (rx335_rep) = rx335_cur."!mark_commit"($I343)
-    rx335_cur."!mark_push"(rx335_rep, rx335_pos, $I343)
-    goto rxquantr342_loop
-  rxquantr342_done:
-    goto alt341_end
-  alt341_2:
-    set_addr $I10, alt341_3
-    rx335_cur."!mark_push"(0, rx335_pos, $I10)
+    lt $I11, $I12, rx320_fail
+    add rx320_pos, rx320_off, $I11
+    set_addr $I10, rxquantr327_done
+    (rx320_rep) = rx320_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr327_done
+    rx320_cur."!mark_push"(rx320_rep, rx320_pos, $I10)
+    goto rxquantr327_loop
+  rxquantr327_done:
+    goto alt326_end
+  alt326_2:
+    set_addr $I10, alt326_3
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
 .annotate 'line', 121
   # rx enumcharlist negate=0 
-    ge rx335_pos, rx335_eos, rx335_fail
-    sub $I10, rx335_pos, rx335_off
-    substr $S10, rx335_tgt, $I10, 1
+    ge rx320_pos, rx320_eos, rx320_fail
+    sub $I10, rx320_pos, rx320_off
+    substr $S10, rx320_tgt, $I10, 1
     index $I11, "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ", $S10
-    lt $I11, 0, rx335_fail
-    inc rx335_pos
-    goto alt341_end
-  alt341_3:
+    lt $I11, 0, rx320_fail
+    inc rx320_pos
+    goto alt326_end
+  alt326_3:
 .annotate 'line', 122
   # rx subrule "panic" subtype=method negate=
-    rx335_cur."!cursor_pos"(rx335_pos)
-    $P10 = rx335_cur."panic"("Unrecognized \\c character")
-    unless $P10, rx335_fail
-    rx335_pos = $P10."pos"()
-  alt341_end:
+    rx320_cur."!cursor_pos"(rx320_pos)
+    $P10 = rx320_cur."panic"("Unrecognized \\c character")
+    unless $P10, rx320_fail
+    rx320_pos = $P10."pos"()
+  alt326_end:
 .annotate 'line', 117
   # rx pass
-    rx335_cur."!cursor_pass"(rx335_pos, "charspec")
-    rx335_cur."!cursor_debug"("PASS  ", "charspec", " at pos=", rx335_pos)
-    .return (rx335_cur)
-  rx335_fail:
-.annotate 'line', 33
-    (rx335_rep, rx335_pos, $I10, $P10) = rx335_cur."!mark_fail"(0)
-    lt rx335_pos, -1, rx335_done
-    eq rx335_pos, -1, rx335_fail
+    rx320_cur."!cursor_pass"(rx320_pos, "charspec")
+    rx320_cur."!cursor_debug"("PASS  ", "charspec", " at pos=", rx320_pos)
+    .return (rx320_cur)
+  rx320_restart:
+.annotate 'line', 33
+    rx320_cur."!cursor_debug"("NEXT ", "charspec")
+  rx320_fail:
+    (rx320_rep, rx320_pos, $I10, $P10) = rx320_cur."!mark_fail"(0)
+    lt rx320_pos, -1, rx320_done
+    eq rx320_pos, -1, rx320_fail
     jump $I10
-  rx335_done:
-    rx335_cur."!cursor_fail"()
-    rx335_cur."!cursor_debug"("FAIL  ", "charspec")
-    .return (rx335_cur)
+  rx320_done:
+    rx320_cur."!cursor_fail"()
+    rx320_cur."!cursor_debug"("FAIL  ", "charspec")
+    .return (rx320_cur)
     .return ()
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "!PREFIX__charspec"  :subid("104_1278500527.62277") :method
-.annotate 'line', 33
-    $P337 = self."!PREFIX__!subrule"("panic", "")
-    $P338 = self."!PREFIX__!subrule"("charnames", "[")
-    new $P339, "ResizablePMCArray"
-    push $P339, $P337
-    push $P339, "Z"
-    push $P339, "Y"
-    push $P339, "X"
-    push $P339, "W"
-    push $P339, "V"
-    push $P339, "U"
-    push $P339, "T"
-    push $P339, "S"
-    push $P339, "R"
-    push $P339, "Q"
-    push $P339, "P"
-    push $P339, "O"
-    push $P339, "N"
-    push $P339, "M"
-    push $P339, "L"
-    push $P339, "K"
-    push $P339, "J"
-    push $P339, "I"
-    push $P339, "H"
-    push $P339, "G"
-    push $P339, "F"
-    push $P339, "E"
-    push $P339, "D"
-    push $P339, "C"
-    push $P339, "B"
-    push $P339, "A"
-    push $P339, "@"
-    push $P339, "?"
-    push $P339, ""
-    push $P339, $P338
-    .return ($P339)
+.sub "!PREFIX__charspec"  :subid("104_1279529214.68208") :method
+.annotate 'line', 33
+    $P322 = self."!PREFIX__!subrule"("panic", "")
+    $P323 = self."!PREFIX__!subrule"("charnames", "[")
+    new $P324, "ResizablePMCArray"
+    push $P324, $P322
+    push $P324, "Z"
+    push $P324, "Y"
+    push $P324, "X"
+    push $P324, "W"
+    push $P324, "V"
+    push $P324, "U"
+    push $P324, "T"
+    push $P324, "S"
+    push $P324, "R"
+    push $P324, "Q"
+    push $P324, "P"
+    push $P324, "O"
+    push $P324, "N"
+    push $P324, "M"
+    push $P324, "L"
+    push $P324, "K"
+    push $P324, "J"
+    push $P324, "I"
+    push $P324, "H"
+    push $P324, "G"
+    push $P324, "F"
+    push $P324, "E"
+    push $P324, "D"
+    push $P324, "C"
+    push $P324, "B"
+    push $P324, "A"
+    push $P324, "@"
+    push $P324, "?"
+    push $P324, ""
+    push $P324, $P323
+    .return ($P324)
 .end
 
 
 .namespace ["HLL";"Grammar"]
-.sub "_block344" :load :anon :subid("105_1278500527.62277")
+.sub "_block328" :load :anon :subid("105_1279529214.68208")
 .annotate 'line', 5
-    .const 'Sub' $P346 = "11_1278500527.62277" 
-    $P347 = $P346()
-    .return ($P347)
+    .const 'Sub' $P330 = "11_1279529214.68208" 
+    $P331 = $P330()
+    .return ($P331)
 .end
 
 
 .namespace []
-.sub "_block349" :load :anon :subid("106_1278500527.62277")
+.sub "_block333" :load :anon :subid("106_1279529214.68208")
 .annotate 'line', 1
-    .const 'Sub' $P351 = "10_1278500527.62277" 
-    $P352 = $P351()
-    .return ($P352)
+    .const 'Sub' $P335 = "10_1279529214.68208" 
+    $P336 = $P335()
+    .return ($P336)
 .end
 
 ### .include 'gen/hllgrammar-actions.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500528.84129")
+.sub "_block11"  :anon :subid("10_1279529216.16216")
 .annotate 'line', 0
     get_hll_global $P14, ["HLL";"Actions"], "_block13" 
     capture_lex $P14
@@ -4913,15 +5099,15 @@
     $P627 = $P14()
 .annotate 'line', 1
     .return ($P627)
-    .const 'Sub' $P629 = "55_1278500528.84129" 
+    .const 'Sub' $P629 = "55_1279529216.16216" 
     .return ($P629)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post56") :outer("10_1278500528.84129")
+.sub "" :load :init :subid("post56") :outer("10_1279529216.16216")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500528.84129" 
+    .const 'Sub' $P12 = "10_1279529216.16216" 
     .local pmc block
     set block, $P12
     $P632 = get_root_global ["parrot"], "P6metaclass"
@@ -4930,75 +5116,75 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block13"  :subid("11_1278500528.84129") :outer("10_1278500528.84129")
+.sub "_block13"  :subid("11_1279529216.16216") :outer("10_1279529216.16216")
 .annotate 'line', 3
-    .const 'Sub' $P605 = "53_1278500528.84129" 
+    .const 'Sub' $P605 = "53_1279529216.16216" 
     capture_lex $P605
-    .const 'Sub' $P580 = "51_1278500528.84129" 
+    .const 'Sub' $P580 = "51_1279529216.16216" 
     capture_lex $P580
-    .const 'Sub' $P550 = "50_1278500528.84129" 
+    .const 'Sub' $P550 = "50_1279529216.16216" 
     capture_lex $P550
-    .const 'Sub' $P531 = "49_1278500528.84129" 
+    .const 'Sub' $P531 = "49_1279529216.16216" 
     capture_lex $P531
-    .const 'Sub' $P524 = "48_1278500528.84129" 
+    .const 'Sub' $P524 = "48_1279529216.16216" 
     capture_lex $P524
-    .const 'Sub' $P514 = "47_1278500528.84129" 
+    .const 'Sub' $P514 = "47_1279529216.16216" 
     capture_lex $P514
-    .const 'Sub' $P497 = "46_1278500528.84129" 
+    .const 'Sub' $P497 = "46_1279529216.16216" 
     capture_lex $P497
-    .const 'Sub' $P480 = "45_1278500528.84129" 
+    .const 'Sub' $P480 = "45_1279529216.16216" 
     capture_lex $P480
-    .const 'Sub' $P473 = "44_1278500528.84129" 
+    .const 'Sub' $P473 = "44_1279529216.16216" 
     capture_lex $P473
-    .const 'Sub' $P466 = "43_1278500528.84129" 
+    .const 'Sub' $P466 = "43_1279529216.16216" 
     capture_lex $P466
-    .const 'Sub' $P459 = "42_1278500528.84129" 
+    .const 'Sub' $P459 = "42_1279529216.16216" 
     capture_lex $P459
-    .const 'Sub' $P452 = "41_1278500528.84129" 
+    .const 'Sub' $P452 = "41_1279529216.16216" 
     capture_lex $P452
-    .const 'Sub' $P445 = "40_1278500528.84129" 
+    .const 'Sub' $P445 = "40_1279529216.16216" 
     capture_lex $P445
-    .const 'Sub' $P438 = "39_1278500528.84129" 
+    .const 'Sub' $P438 = "39_1279529216.16216" 
     capture_lex $P438
-    .const 'Sub' $P428 = "38_1278500528.84129" 
+    .const 'Sub' $P428 = "38_1279529216.16216" 
     capture_lex $P428
-    .const 'Sub' $P421 = "37_1278500528.84129" 
+    .const 'Sub' $P421 = "37_1279529216.16216" 
     capture_lex $P421
-    .const 'Sub' $P405 = "36_1278500528.84129" 
+    .const 'Sub' $P405 = "36_1279529216.16216" 
     capture_lex $P405
-    .const 'Sub' $P330 = "34_1278500528.84129" 
+    .const 'Sub' $P330 = "34_1279529216.16216" 
     capture_lex $P330
-    .const 'Sub' $P267 = "31_1278500528.84129" 
+    .const 'Sub' $P267 = "31_1279529216.16216" 
     capture_lex $P267
-    .const 'Sub' $P258 = "30_1278500528.84129" 
+    .const 'Sub' $P258 = "30_1279529216.16216" 
     capture_lex $P258
-    .const 'Sub' $P249 = "29_1278500528.84129" 
+    .const 'Sub' $P249 = "29_1279529216.16216" 
     capture_lex $P249
-    .const 'Sub' $P240 = "28_1278500528.84129" 
+    .const 'Sub' $P240 = "28_1279529216.16216" 
     capture_lex $P240
-    .const 'Sub' $P231 = "27_1278500528.84129" 
+    .const 'Sub' $P231 = "27_1279529216.16216" 
     capture_lex $P231
-    .const 'Sub' $P222 = "26_1278500528.84129" 
+    .const 'Sub' $P222 = "26_1279529216.16216" 
     capture_lex $P222
-    .const 'Sub' $P212 = "25_1278500528.84129" 
+    .const 'Sub' $P212 = "25_1279529216.16216" 
     capture_lex $P212
-    .const 'Sub' $P202 = "24_1278500528.84129" 
+    .const 'Sub' $P202 = "24_1279529216.16216" 
     capture_lex $P202
-    .const 'Sub' $P194 = "23_1278500528.84129" 
+    .const 'Sub' $P194 = "23_1279529216.16216" 
     capture_lex $P194
-    .const 'Sub' $P184 = "22_1278500528.84129" 
+    .const 'Sub' $P184 = "22_1279529216.16216" 
     capture_lex $P184
-    .const 'Sub' $P174 = "21_1278500528.84129" 
+    .const 'Sub' $P174 = "21_1279529216.16216" 
     capture_lex $P174
-    .const 'Sub' $P73 = "18_1278500528.84129" 
+    .const 'Sub' $P73 = "18_1279529216.16216" 
     capture_lex $P73
-    .const 'Sub' $P35 = "15_1278500528.84129" 
+    .const 'Sub' $P35 = "15_1279529216.16216" 
     capture_lex $P35
-    .const 'Sub' $P28 = "14_1278500528.84129" 
+    .const 'Sub' $P28 = "14_1279529216.16216" 
     capture_lex $P28
-    .const 'Sub' $P22 = "13_1278500528.84129" 
+    .const 'Sub' $P22 = "13_1279529216.16216" 
     capture_lex $P22
-    .const 'Sub' $P15 = "12_1278500528.84129" 
+    .const 'Sub' $P15 = "12_1279529216.16216" 
     capture_lex $P15
     $P0 = find_dynamic_lex "$*CTXSAVE"
     if null $P0 goto ctxsave_done
@@ -5007,18 +5193,18 @@
     $P0."ctxsave"()
   ctxsave_done:
 .annotate 'line', 225
-    .const 'Sub' $P605 = "53_1278500528.84129" 
+    .const 'Sub' $P605 = "53_1279529216.16216" 
     newclosure $P622, $P605
 .annotate 'line', 3
     .return ($P622)
-    .const 'Sub' $P624 = "54_1278500528.84129" 
+    .const 'Sub' $P624 = "54_1279529216.16216" 
     .return ($P624)
 .end
 
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "string_to_int"  :subid("12_1278500528.84129") :outer("11_1278500528.84129")
+.sub "string_to_int"  :subid("12_1279529216.16216") :outer("11_1279529216.16216")
     .param pmc param_18
     .param pmc param_19
 .annotate 'line', 3
@@ -5072,7 +5258,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "ints_to_string"  :subid("13_1278500528.84129") :outer("11_1278500528.84129")
+.sub "ints_to_string"  :subid("13_1279529216.16216") :outer("11_1279529216.16216")
     .param pmc param_25
 .annotate 'line', 37
     new $P24, 'ExceptionHandler'
@@ -5114,7 +5300,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "CTXSAVE"  :subid("14_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "CTXSAVE"  :subid("14_1279529216.16216") :method :outer("11_1279529216.16216")
 .annotate 'line', 62
     new $P30, 'ExceptionHandler'
     set_addr $P30, control_29
@@ -5144,10 +5330,10 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "SET_BLOCK_OUTER_CTX"  :subid("15_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "SET_BLOCK_OUTER_CTX"  :subid("15_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_38
 .annotate 'line', 76
-    .const 'Sub' $P48 = "16_1278500528.84129" 
+    .const 'Sub' $P48 = "16_1279529216.16216" 
     capture_lex $P48
     new $P37, 'ExceptionHandler'
     set_addr $P37, control_36
@@ -5182,7 +5368,7 @@
     set $P43, $I46
     goto if_44_end
   if_44:
-    .const 'Sub' $P48 = "16_1278500528.84129" 
+    .const 'Sub' $P48 = "16_1279529216.16216" 
     capture_lex $P48
     $P71 = $P48()
     set $P43, $P71
@@ -5199,9 +5385,9 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "_block47"  :anon :subid("16_1278500528.84129") :outer("15_1278500528.84129")
+.sub "_block47"  :anon :subid("16_1279529216.16216") :outer("15_1279529216.16216")
 .annotate 'line', 78
-    .const 'Sub' $P62 = "17_1278500528.84129" 
+    .const 'Sub' $P62 = "17_1279529216.16216" 
     capture_lex $P62
 .annotate 'line', 79
     $P49 = root_new ['parrot';'ResizablePMCArray']
@@ -5231,7 +5417,7 @@
     unless $P56, loop68_done
     shift $P60, $P56
   loop68_redo:
-    .const 'Sub' $P62 = "17_1278500528.84129" 
+    .const 'Sub' $P62 = "17_1279529216.16216" 
     capture_lex $P62
     $P62($P60)
   loop68_next:
@@ -5251,7 +5437,7 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block61"  :anon :subid("17_1278500528.84129") :outer("16_1278500528.84129")
+.sub "_block61"  :anon :subid("17_1279529216.16216") :outer("16_1279529216.16216")
     .param pmc param_63
 .annotate 'line', 82
     .lex "$_", param_63
@@ -5267,14 +5453,14 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "EXPR"  :subid("18_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "EXPR"  :subid("18_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_76
     .param pmc param_77 :optional
     .param int has_param_77 :opt_flag
 .annotate 'line', 89
-    .const 'Sub' $P156 = "20_1278500528.84129" 
+    .const 'Sub' $P156 = "20_1279529216.16216" 
     capture_lex $P156
-    .const 'Sub' $P123 = "19_1278500528.84129" 
+    .const 'Sub' $P123 = "19_1279529216.16216" 
     capture_lex $P123
     new $P75, 'ExceptionHandler'
     set_addr $P75, control_74
@@ -5409,7 +5595,7 @@
     find_lex $P120, "$past"
     $P121 = $P120."name"()
     if $P121, unless_119_end
-    .const 'Sub' $P123 = "19_1278500528.84129" 
+    .const 'Sub' $P123 = "19_1279529216.16216" 
     capture_lex $P123
     $P123()
   unless_119_end:
@@ -5433,7 +5619,7 @@
     unless $P150, loop167_done
     shift $P154, $P150
   loop167_redo:
-    .const 'Sub' $P156 = "20_1278500528.84129" 
+    .const 'Sub' $P156 = "20_1279529216.16216" 
     capture_lex $P156
     $P156($P154)
   loop167_next:
@@ -5478,7 +5664,7 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block122"  :anon :subid("19_1278500528.84129") :outer("18_1278500528.84129")
+.sub "_block122"  :anon :subid("19_1279529216.16216") :outer("18_1279529216.16216")
 .annotate 'line', 98
     new $P124, "Undef"
     .lex "$name", $P124
@@ -5528,7 +5714,7 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block155"  :anon :subid("20_1278500528.84129") :outer("18_1278500528.84129")
+.sub "_block155"  :anon :subid("20_1279529216.16216") :outer("18_1279529216.16216")
     .param pmc param_157
 .annotate 'line', 109
     .lex "$_", param_157
@@ -5552,7 +5738,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<circumfix>"  :subid("21_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "term:sym<circumfix>"  :subid("21_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_177
 .annotate 'line', 114
     new $P176, 'ExceptionHandler'
@@ -5583,7 +5769,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "termish"  :subid("22_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "termish"  :subid("22_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_187
 .annotate 'line', 116
     new $P186, 'ExceptionHandler'
@@ -5614,7 +5800,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "nullterm"  :subid("23_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "nullterm"  :subid("23_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_197
 .annotate 'line', 117
     new $P196, 'ExceptionHandler'
@@ -5637,7 +5823,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "nullterm_alt"  :subid("24_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "nullterm_alt"  :subid("24_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_205
 .annotate 'line', 118
     new $P204, 'ExceptionHandler'
@@ -5668,7 +5854,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "integer"  :subid("25_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "integer"  :subid("25_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_215
 .annotate 'line', 120
     new $P214, 'ExceptionHandler'
@@ -5699,7 +5885,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "dec_number"  :subid("26_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "dec_number"  :subid("26_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_225
 .annotate 'line', 122
     new $P224, 'ExceptionHandler'
@@ -5723,7 +5909,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "decint"  :subid("27_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "decint"  :subid("27_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_234
 .annotate 'line', 124
     new $P233, 'ExceptionHandler'
@@ -5747,7 +5933,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "hexint"  :subid("28_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "hexint"  :subid("28_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_243
 .annotate 'line', 125
     new $P242, 'ExceptionHandler'
@@ -5771,7 +5957,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "octint"  :subid("29_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "octint"  :subid("29_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_252
 .annotate 'line', 126
     new $P251, 'ExceptionHandler'
@@ -5795,7 +5981,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "binint"  :subid("30_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "binint"  :subid("30_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_261
 .annotate 'line', 127
     new $P260, 'ExceptionHandler'
@@ -5819,10 +6005,10 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_EXPR"  :subid("31_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_EXPR"  :subid("31_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_270
 .annotate 'line', 129
-    .const 'Sub' $P286 = "32_1278500528.84129" 
+    .const 'Sub' $P286 = "32_1279529216.16216" 
     capture_lex $P286
     new $P269, 'ExceptionHandler'
     set_addr $P269, control_268
@@ -5854,7 +6040,7 @@
     $P282 = $P280."ACCEPTS"($P281)
     if $P282, if_279
 .annotate 'line', 135
-    .const 'Sub' $P286 = "32_1278500528.84129" 
+    .const 'Sub' $P286 = "32_1279529216.16216" 
     capture_lex $P286
     $P286()
     goto if_279_end
@@ -5894,9 +6080,9 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "_block285"  :anon :subid("32_1278500528.84129") :outer("31_1278500528.84129")
+.sub "_block285"  :anon :subid("32_1279529216.16216") :outer("31_1279529216.16216")
 .annotate 'line', 135
-    .const 'Sub' $P305 = "33_1278500528.84129" 
+    .const 'Sub' $P305 = "33_1279529216.16216" 
     capture_lex $P305
 .annotate 'line', 136
     $P287 = root_new ['parrot';'ResizablePMCArray']
@@ -5947,7 +6133,7 @@
     unless $P300, loop310_done
     shift $P303, $P300
   loop310_redo:
-    .const 'Sub' $P305 = "33_1278500528.84129" 
+    .const 'Sub' $P305 = "33_1279529216.16216" 
     capture_lex $P305
     $P305($P303)
   loop310_next:
@@ -5970,7 +6156,7 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block304"  :anon :subid("33_1278500528.84129") :outer("32_1278500528.84129")
+.sub "_block304"  :anon :subid("33_1279529216.16216") :outer("32_1279529216.16216")
     .param pmc param_306
 .annotate 'line', 139
     .lex "$_", param_306
@@ -5983,10 +6169,10 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_delimited"  :subid("34_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_delimited"  :subid("34_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_333
 .annotate 'line', 152
-    .const 'Sub' $P345 = "35_1278500528.84129" 
+    .const 'Sub' $P345 = "35_1279529216.16216" 
     capture_lex $P345
     new $P332, 'ExceptionHandler'
     set_addr $P332, control_331
@@ -6029,7 +6215,7 @@
     unless $P339, loop377_done
     shift $P343, $P339
   loop377_redo:
-    .const 'Sub' $P345 = "35_1278500528.84129" 
+    .const 'Sub' $P345 = "35_1279529216.16216" 
     capture_lex $P345
     $P345($P343)
   loop377_next:
@@ -6107,7 +6293,7 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block344"  :anon :subid("35_1278500528.84129") :outer("34_1278500528.84129")
+.sub "_block344"  :anon :subid("35_1279529216.16216") :outer("34_1279529216.16216")
     .param pmc param_347
 .annotate 'line', 156
     new $P346, "Undef"
@@ -6177,7 +6363,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_atom"  :subid("36_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_atom"  :subid("36_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_408
 .annotate 'line', 177
     new $P407, 'ExceptionHandler'
@@ -6227,7 +6413,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<backslash>"  :subid("37_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<backslash>"  :subid("37_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_424
 .annotate 'line', 181
     new $P423, 'ExceptionHandler'
@@ -6249,7 +6435,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<stopper>"  :subid("38_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<stopper>"  :subid("38_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_431
 .annotate 'line', 182
     new $P430, 'ExceptionHandler'
@@ -6280,7 +6466,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<bs>"  :subid("39_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<bs>"  :subid("39_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_441
 .annotate 'line', 184
     new $P440, 'ExceptionHandler'
@@ -6302,7 +6488,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<nl>"  :subid("40_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<nl>"  :subid("40_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_448
 .annotate 'line', 185
     new $P447, 'ExceptionHandler'
@@ -6324,7 +6510,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<cr>"  :subid("41_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<cr>"  :subid("41_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_455
 .annotate 'line', 186
     new $P454, 'ExceptionHandler'
@@ -6346,7 +6532,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<tab>"  :subid("42_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<tab>"  :subid("42_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_462
 .annotate 'line', 187
     new $P461, 'ExceptionHandler'
@@ -6368,7 +6554,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<ff>"  :subid("43_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<ff>"  :subid("43_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_469
 .annotate 'line', 188
     new $P468, 'ExceptionHandler'
@@ -6390,7 +6576,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<esc>"  :subid("44_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<esc>"  :subid("44_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_476
 .annotate 'line', 189
     new $P475, 'ExceptionHandler'
@@ -6412,7 +6598,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<hex>"  :subid("45_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<hex>"  :subid("45_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_483
 .annotate 'line', 191
     new $P482, 'ExceptionHandler'
@@ -6471,7 +6657,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<oct>"  :subid("46_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<oct>"  :subid("46_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_500
 .annotate 'line', 195
     new $P499, 'ExceptionHandler'
@@ -6530,7 +6716,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<chr>"  :subid("47_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<chr>"  :subid("47_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_517
 .annotate 'line', 199
     new $P516, 'ExceptionHandler'
@@ -6563,7 +6749,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<0>"  :subid("48_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<0>"  :subid("48_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_527
 .annotate 'line', 203
     new $P526, 'ExceptionHandler'
@@ -6587,7 +6773,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<misc>"  :subid("49_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "quote_escape:sym<misc>"  :subid("49_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_534
 .annotate 'line', 207
     new $P533, 'ExceptionHandler'
@@ -6646,7 +6832,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "charname"  :subid("50_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "charname"  :subid("50_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_553
 .annotate 'line', 211
     new $P552, 'ExceptionHandler'
@@ -6720,10 +6906,10 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "charnames"  :subid("51_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "charnames"  :subid("51_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_583
 .annotate 'line', 219
-    .const 'Sub' $P592 = "52_1278500528.84129" 
+    .const 'Sub' $P592 = "52_1279529216.16216" 
     capture_lex $P592
     new $P582, 'ExceptionHandler'
     set_addr $P582, control_581
@@ -6757,7 +6943,7 @@
     unless $P586, loop598_done
     shift $P590, $P586
   loop598_redo:
-    .const 'Sub' $P592 = "52_1278500528.84129" 
+    .const 'Sub' $P592 = "52_1279529216.16216" 
     capture_lex $P592
     $P592($P590)
   loop598_next:
@@ -6786,7 +6972,7 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block591"  :anon :subid("52_1278500528.84129") :outer("51_1278500528.84129")
+.sub "_block591"  :anon :subid("52_1279529216.16216") :outer("51_1279529216.16216")
     .param pmc param_593
 .annotate 'line', 221
     .lex "$_", param_593
@@ -6801,7 +6987,7 @@
 
 .namespace ["HLL";"Actions"]
 .include "except_types.pasm"
-.sub "charspec"  :subid("53_1278500528.84129") :method :outer("11_1278500528.84129")
+.sub "charspec"  :subid("53_1279529216.16216") :method :outer("11_1279529216.16216")
     .param pmc param_608
 .annotate 'line', 225
     new $P607, 'ExceptionHandler'
@@ -6851,18 +7037,18 @@
 
 
 .namespace ["HLL";"Actions"]
-.sub "_block623" :load :anon :subid("54_1278500528.84129")
+.sub "_block623" :load :anon :subid("54_1279529216.16216")
 .annotate 'line', 3
-    .const 'Sub' $P625 = "11_1278500528.84129" 
+    .const 'Sub' $P625 = "11_1279529216.16216" 
     $P626 = $P625()
     .return ($P626)
 .end
 
 
 .namespace []
-.sub "_block628" :load :anon :subid("55_1278500528.84129")
+.sub "_block628" :load :anon :subid("55_1279529216.16216")
 .annotate 'line', 1
-    .const 'Sub' $P630 = "10_1278500528.84129" 
+    .const 'Sub' $P630 = "10_1279529216.16216" 
     $P631 = $P630()
     .return ($P631)
 .end
@@ -6870,7 +7056,7 @@
 ### .include 'gen/hllcompiler.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500529.62668")
+.sub "_block11"  :anon :subid("10_1279529217.12806")
 .annotate 'line', 0
     get_hll_global $P14, ["HLL";"Compiler"], "_block13" 
     capture_lex $P14
@@ -6887,15 +7073,15 @@
     $P497 = $P14()
 .annotate 'line', 1
     .return ($P497)
-    .const 'Sub' $P499 = "36_1278500529.62668" 
+    .const 'Sub' $P499 = "36_1279529217.12806" 
     .return ($P499)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post37") :outer("10_1278500529.62668")
+.sub "" :load :init :subid("post37") :outer("10_1279529217.12806")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500529.62668" 
+    .const 'Sub' $P12 = "10_1279529217.12806" 
     .local pmc block
     set block, $P12
 .annotate 'line', 2
@@ -6909,36 +7095,36 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block13"  :subid("11_1278500529.62668") :outer("10_1278500529.62668")
+.sub "_block13"  :subid("11_1279529217.12806") :outer("10_1279529217.12806")
 .annotate 'line', 6
-    .const 'Sub' $P489 = "35_1278500529.62668" 
+    .const 'Sub' $P489 = "35_1279529217.12806" 
     capture_lex $P489
-    .const 'Sub' $P447 = "33_1278500529.62668" 
+    .const 'Sub' $P447 = "33_1279529217.12806" 
     capture_lex $P447
-    .const 'Sub' $P298 = "26_1278500529.62668" 
+    .const 'Sub' $P298 = "26_1279529217.12806" 
     capture_lex $P298
-    .const 'Sub' $P283 = "25_1278500529.62668" 
+    .const 'Sub' $P283 = "25_1279529217.12806" 
     capture_lex $P283
-    .const 'Sub' $P188 = "20_1278500529.62668" 
+    .const 'Sub' $P188 = "20_1279529217.12806" 
     capture_lex $P188
-    .const 'Sub' $P153 = "18_1278500529.62668" 
+    .const 'Sub' $P153 = "18_1279529217.12806" 
     capture_lex $P153
-    .const 'Sub' $P138 = "17_1278500529.62668" 
+    .const 'Sub' $P138 = "17_1279529217.12806" 
     capture_lex $P138
-    .const 'Sub' $P122 = "16_1278500529.62668" 
+    .const 'Sub' $P122 = "16_1279529217.12806" 
     capture_lex $P122
-    .const 'Sub' $P33 = "13_1278500529.62668" 
+    .const 'Sub' $P33 = "13_1279529217.12806" 
     capture_lex $P33
-    .const 'Sub' $P15 = "12_1278500529.62668" 
+    .const 'Sub' $P15 = "12_1279529217.12806" 
     capture_lex $P15
 .annotate 'line', 14
-    .const 'Sub' $P15 = "12_1278500529.62668" 
+    .const 'Sub' $P15 = "12_1279529217.12806" 
     newclosure $P31, $P15
     .lex "value_type", $P31
 .annotate 'line', 10
     find_lex $P32, "value_type"
 .annotate 'line', 165
-    .const 'Sub' $P489 = "35_1278500529.62668" 
+    .const 'Sub' $P489 = "35_1279529217.12806" 
     newclosure $P495, $P489
 .annotate 'line', 6
     .return ($P495)
@@ -6946,7 +7132,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "" :load :init :subid("post38") :outer("11_1278500529.62668")
+.sub "" :load :init :subid("post38") :outer("11_1279529217.12806")
 .annotate 'line', 6
     get_hll_global $P14, ["HLL";"Compiler"], "_block13" 
     .local pmc block
@@ -6959,7 +7145,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "value_type"  :subid("12_1278500529.62668") :outer("11_1278500529.62668")
+.sub "value_type"  :subid("12_1279529217.12806") :outer("11_1279529217.12806")
     .param pmc param_18
 .annotate 'line', 14
     new $P17, 'ExceptionHandler'
@@ -7004,15 +7190,15 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "get_exports"  :subid("13_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "get_exports"  :subid("13_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_36
     .param pmc param_39 :slurpy
     .param pmc param_37 :optional :named("tagset")
     .param int has_param_37 :opt_flag
 .annotate 'line', 20
-    .const 'Sub' $P105 = "15_1278500529.62668" 
+    .const 'Sub' $P105 = "15_1279529217.12806" 
     capture_lex $P105
-    .const 'Sub' $P84 = "14_1278500529.62668" 
+    .const 'Sub' $P84 = "14_1279529217.12806" 
     capture_lex $P84
     new $P35, 'ExceptionHandler'
     set_addr $P35, control_34
@@ -7118,7 +7304,7 @@
     unless $P100, loop117_done
     shift $P103, $P100
   loop117_redo:
-    .const 'Sub' $P105 = "15_1278500529.62668" 
+    .const 'Sub' $P105 = "15_1279529217.12806" 
     capture_lex $P105
     $P105($P103)
   loop117_next:
@@ -7148,7 +7334,7 @@
     unless $P79, loop97_done
     shift $P82, $P79
   loop97_redo:
-    .const 'Sub' $P84 = "14_1278500529.62668" 
+    .const 'Sub' $P84 = "14_1279529217.12806" 
     capture_lex $P84
     $P84($P82)
   loop97_next:
@@ -7176,7 +7362,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block104"  :anon :subid("15_1278500529.62668") :outer("13_1278500529.62668")
+.sub "_block104"  :anon :subid("15_1279529217.12806") :outer("13_1279529217.12806")
     .param pmc param_107
 .annotate 'line', 40
     new $P106, "Undef"
@@ -7208,7 +7394,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block83"  :anon :subid("14_1278500529.62668") :outer("13_1278500529.62668")
+.sub "_block83"  :anon :subid("14_1279529217.12806") :outer("13_1279529217.12806")
     .param pmc param_86
 .annotate 'line', 34
     new $P85, "Undef"
@@ -7248,7 +7434,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "get_module"  :subid("16_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "get_module"  :subid("16_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_125
 .annotate 'line', 47
     new $P124, 'ExceptionHandler'
@@ -7289,7 +7475,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "language"  :subid("17_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "language"  :subid("17_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_141 :optional
     .param int has_param_141 :opt_flag
 .annotate 'line', 53
@@ -7334,10 +7520,10 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "load_module"  :subid("18_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "load_module"  :subid("18_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_156
 .annotate 'line', 61
-    .const 'Sub' $P166 = "19_1278500529.62668" 
+    .const 'Sub' $P166 = "19_1279529217.12806" 
     capture_lex $P166
     new $P155, 'ExceptionHandler'
     set_addr $P155, control_154
@@ -7364,7 +7550,7 @@
     assign $P164, 0
     store_lex "$loaded", $P164
 .annotate 'line', 64
-    .const 'Sub' $P166 = "19_1278500529.62668" 
+    .const 'Sub' $P166 = "19_1279529217.12806" 
     capture_lex $P166
     $P166()
 .annotate 'line', 65
@@ -7394,7 +7580,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block165"  :anon :subid("19_1278500529.62668") :outer("18_1278500529.62668")
+.sub "_block165"  :anon :subid("19_1279529217.12806") :outer("18_1279529217.12806")
 .annotate 'line', 64
     new $P173, 'ExceptionHandler'
     set_addr $P173, control_172
@@ -7428,11 +7614,11 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "import"  :subid("20_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "import"  :subid("20_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_191
     .param pmc param_192
 .annotate 'line', 69
-    .const 'Sub' $P198 = "21_1278500529.62668" 
+    .const 'Sub' $P198 = "21_1279529217.12806" 
     capture_lex $P198
     new $P190, 'ExceptionHandler'
     set_addr $P190, control_189
@@ -7454,7 +7640,7 @@
     unless $P193, loop279_done
     shift $P196, $P193
   loop279_redo:
-    .const 'Sub' $P198 = "21_1278500529.62668" 
+    .const 'Sub' $P198 = "21_1279529217.12806" 
     capture_lex $P198
     $P198($P196)
   loop279_next:
@@ -7480,14 +7666,14 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block197"  :anon :subid("21_1278500529.62668") :outer("20_1278500529.62668")
+.sub "_block197"  :anon :subid("21_1279529217.12806") :outer("20_1279529217.12806")
     .param pmc param_201
 .annotate 'line', 70
-    .const 'Sub' $P268 = "24_1278500529.62668" 
+    .const 'Sub' $P268 = "24_1279529217.12806" 
     capture_lex $P268
-    .const 'Sub' $P248 = "23_1278500529.62668" 
+    .const 'Sub' $P248 = "23_1279529217.12806" 
     capture_lex $P248
-    .const 'Sub' $P219 = "22_1278500529.62668" 
+    .const 'Sub' $P219 = "22_1279529217.12806" 
     capture_lex $P219
 .annotate 'line', 71
     new $P199, "Undef"
@@ -7535,7 +7721,7 @@
     unless $P263, loop276_done
     shift $P266, $P263
   loop276_redo:
-    .const 'Sub' $P268 = "24_1278500529.62668" 
+    .const 'Sub' $P268 = "24_1279529217.12806" 
     capture_lex $P268
     $P268($P266)
   loop276_next:
@@ -7567,7 +7753,7 @@
     unless $P243, loop260_done
     shift $P246, $P243
   loop260_redo:
-    .const 'Sub' $P248 = "23_1278500529.62668" 
+    .const 'Sub' $P248 = "23_1279529217.12806" 
     capture_lex $P248
     $P248($P246)
   loop260_next:
@@ -7601,7 +7787,7 @@
     unless $P214, loop232_done
     shift $P217, $P214
   loop232_redo:
-    .const 'Sub' $P219 = "22_1278500529.62668" 
+    .const 'Sub' $P219 = "22_1279529217.12806" 
     capture_lex $P219
     $P219($P217)
   loop232_next:
@@ -7624,7 +7810,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block267"  :anon :subid("24_1278500529.62668") :outer("21_1278500529.62668")
+.sub "_block267"  :anon :subid("24_1279529217.12806") :outer("21_1279529217.12806")
     .param pmc param_269
 .annotate 'line', 80
     .lex "$_", param_269
@@ -7644,7 +7830,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block247"  :anon :subid("23_1278500529.62668") :outer("21_1278500529.62668")
+.sub "_block247"  :anon :subid("23_1279529217.12806") :outer("21_1279529217.12806")
     .param pmc param_249
 .annotate 'line', 77
     .lex "$_", param_249
@@ -7664,7 +7850,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block218"  :anon :subid("22_1278500529.62668") :outer("21_1278500529.62668")
+.sub "_block218"  :anon :subid("22_1279529217.12806") :outer("21_1279529217.12806")
     .param pmc param_220
 .annotate 'line', 74
     .lex "$_", param_220
@@ -7686,7 +7872,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "autoprint"  :subid("25_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "autoprint"  :subid("25_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_286
 .annotate 'line', 85
     new $P285, 'ExceptionHandler'
@@ -7730,10 +7916,10 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "interactive"  :subid("26_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "interactive"  :subid("26_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_301 :slurpy :named
 .annotate 'line', 90
-    .const 'Sub' $P333 = "27_1278500529.62668" 
+    .const 'Sub' $P333 = "27_1279529217.12806" 
     capture_lex $P333
     new $P300, 'ExceptionHandler'
     set_addr $P300, control_299
@@ -7820,7 +8006,7 @@
     assign $P331, 1
     unless $P331, loop443_done
   loop443_redo:
-    .const 'Sub' $P333 = "27_1278500529.62668" 
+    .const 'Sub' $P333 = "27_1279529217.12806" 
     capture_lex $P333
     $P333()
   loop443_next:
@@ -7845,9 +8031,9 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block332"  :anon :subid("27_1278500529.62668") :outer("26_1278500529.62668")
+.sub "_block332"  :anon :subid("27_1279529217.12806") :outer("26_1279529217.12806")
 .annotate 'line', 102
-    .const 'Sub' $P365 = "28_1278500529.62668" 
+    .const 'Sub' $P365 = "28_1279529217.12806" 
     capture_lex $P365
 .annotate 'line', 105
     new $P334, "Undef"
@@ -7915,7 +8101,7 @@
     set $P361, $P363
     goto if_362_end
   if_362:
-    .const 'Sub' $P365 = "28_1278500529.62668" 
+    .const 'Sub' $P365 = "28_1279529217.12806" 
     capture_lex $P365
     $P442 = $P365()
     set $P361, $P442
@@ -7927,11 +8113,11 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block364"  :anon :subid("28_1278500529.62668") :outer("27_1278500529.62668")
+.sub "_block364"  :anon :subid("28_1279529217.12806") :outer("27_1279529217.12806")
 .annotate 'line', 115
-    .const 'Sub' $P398 = "31_1278500529.62668" 
+    .const 'Sub' $P398 = "31_1279529217.12806" 
     capture_lex $P398
-    .const 'Sub' $P371 = "29_1278500529.62668" 
+    .const 'Sub' $P371 = "29_1279529217.12806" 
     capture_lex $P371
 .annotate 'line', 117
     new $P366, "Undef"
@@ -7942,7 +8128,7 @@
     store_lex "$code", $P368
     find_lex $P369, "$output"
 .annotate 'line', 118
-    .const 'Sub' $P371 = "29_1278500529.62668" 
+    .const 'Sub' $P371 = "29_1279529217.12806" 
     capture_lex $P371
     $P371()
 .annotate 'line', 125
@@ -7955,7 +8141,7 @@
   vivify_67:
     defined $I396, $P395
     unless $I396, if_394_end
-    .const 'Sub' $P398 = "31_1278500529.62668" 
+    .const 'Sub' $P398 = "31_1279529217.12806" 
     capture_lex $P398
     $P398()
   if_394_end:
@@ -8009,9 +8195,9 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block370"  :anon :subid("29_1278500529.62668") :outer("28_1278500529.62668")
+.sub "_block370"  :anon :subid("29_1279529217.12806") :outer("28_1279529217.12806")
 .annotate 'line', 118
-    .const 'Sub' $P383 = "30_1278500529.62668" 
+    .const 'Sub' $P383 = "30_1279529217.12806" 
     capture_lex $P383
     new $P379, 'ExceptionHandler'
     set_addr $P379, control_378
@@ -8031,7 +8217,7 @@
 .annotate 'line', 120
     .local pmc exception 
     .get_results (exception) 
-    .const 'Sub' $P383 = "30_1278500529.62668" 
+    .const 'Sub' $P383 = "30_1279529217.12806" 
     newclosure $P391, $P383
     $P391(exception)
     new $P392, 'Integer'
@@ -8051,7 +8237,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block382"  :anon :subid("30_1278500529.62668") :outer("29_1278500529.62668")
+.sub "_block382"  :anon :subid("30_1279529217.12806") :outer("29_1279529217.12806")
     .param pmc param_384
 .annotate 'line', 120
     .lex "$_", param_384
@@ -8074,9 +8260,9 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "_block397"  :anon :subid("31_1278500529.62668") :outer("28_1278500529.62668")
+.sub "_block397"  :anon :subid("31_1279529217.12806") :outer("28_1279529217.12806")
 .annotate 'line', 125
-    .const 'Sub' $P409 = "32_1278500529.62668" 
+    .const 'Sub' $P409 = "32_1279529217.12806" 
     capture_lex $P409
 .annotate 'line', 126
     get_global $P399, "$interactive_ctx"
@@ -8113,7 +8299,7 @@
     unless $P403, loop416_done
     shift $P407, $P403
   loop416_redo:
-    .const 'Sub' $P409 = "32_1278500529.62668" 
+    .const 'Sub' $P409 = "32_1279529217.12806" 
     capture_lex $P409
     $P409($P407)
   loop416_next:
@@ -8136,7 +8322,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block408"  :anon :subid("32_1278500529.62668") :outer("31_1278500529.62668")
+.sub "_block408"  :anon :subid("32_1279529217.12806") :outer("31_1279529217.12806")
     .param pmc param_410
 .annotate 'line', 128
     .lex "$_", param_410
@@ -8158,12 +8344,12 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "eval"  :subid("33_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "eval"  :subid("33_1279529217.12806") :method :outer("11_1279529217.12806")
     .param pmc param_450
     .param pmc param_451 :slurpy
     .param pmc param_452 :slurpy :named
 .annotate 'line', 146
-    .const 'Sub' $P471 = "34_1278500529.62668" 
+    .const 'Sub' $P471 = "34_1279529217.12806" 
     capture_lex $P471
     new $P449, 'ExceptionHandler'
     set_addr $P449, control_448
@@ -8210,7 +8396,7 @@
     set $P460, $I469
   if_461_end:
     unless $P460, if_459_end
-    .const 'Sub' $P471 = "34_1278500529.62668" 
+    .const 'Sub' $P471 = "34_1279529217.12806" 
     capture_lex $P471
     $P471()
   if_459_end:
@@ -8227,7 +8413,7 @@
 
 
 .namespace ["HLL";"Compiler"]
-.sub "_block470"  :anon :subid("34_1278500529.62668") :outer("33_1278500529.62668")
+.sub "_block470"  :anon :subid("34_1279529217.12806") :outer("33_1279529217.12806")
 .annotate 'line', 152
     new $P472, "Undef"
     .lex "$outer_ctx", $P472
@@ -8281,7 +8467,7 @@
 
 .namespace ["HLL";"Compiler"]
 .include "except_types.pasm"
-.sub "ctxsave"  :subid("35_1278500529.62668") :method :outer("11_1278500529.62668")
+.sub "ctxsave"  :subid("35_1279529217.12806") :method :outer("11_1279529217.12806")
 .annotate 'line', 165
     new $P491, 'ExceptionHandler'
     set_addr $P491, control_490
@@ -8309,9 +8495,9 @@
 
 
 .namespace []
-.sub "_block498" :load :anon :subid("36_1278500529.62668")
+.sub "_block498" :load :anon :subid("36_1279529217.12806")
 .annotate 'line', 1
-    .const 'Sub' $P500 = "10_1278500529.62668" 
+    .const 'Sub' $P500 = "10_1279529217.12806" 
     $P501 = $P500()
     .return ($P501)
 .end

Modified: trunk/ext/nqp-rx/src/stage0/NQP-s0.pir
==============================================================================
--- trunk/ext/nqp-rx/src/stage0/NQP-s0.pir	Mon Jul 19 07:59:55 2010	(r48109)
+++ trunk/ext/nqp-rx/src/stage0/NQP-s0.pir	Mon Jul 19 09:38:32 2010	(r48110)
@@ -15,7 +15,7 @@
 ### .include 'gen/nqp-grammar.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500537.15927")
+.sub "_block11"  :anon :subid("10_1279529226.73787")
 .annotate 'line', 0
     get_hll_global $P14, ["NQP";"Grammar"], "_block13" 
     capture_lex $P14
@@ -29,341 +29,341 @@
 .annotate 'line', 4
     get_hll_global $P14, ["NQP";"Grammar"], "_block13" 
     capture_lex $P14
-    $P1456 = $P14()
+    $P1423 = $P14()
 .annotate 'line', 1
-    .return ($P1456)
-    .const 'Sub' $P1458 = "371_1278500537.15927" 
-    .return ($P1458)
+    .return ($P1423)
+    .const 'Sub' $P1425 = "371_1279529226.73787" 
+    .return ($P1425)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post372") :outer("10_1278500537.15927")
+.sub "" :load :init :subid("post372") :outer("10_1279529226.73787")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500537.15927" 
+    .const 'Sub' $P12 = "10_1279529226.73787" 
     .local pmc block
     set block, $P12
-    $P1461 = get_root_global ["parrot"], "P6metaclass"
-    $P1461."new_class"("NQP::Grammar", "HLL::Grammar" :named("parent"))
+    $P1428 = get_root_global ["parrot"], "P6metaclass"
+    $P1428."new_class"("NQP::Grammar", "HLL::Grammar" :named("parent"))
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block13"  :subid("11_1278500537.15927") :outer("10_1278500537.15927")
+.sub "_block13"  :subid("11_1279529226.73787") :outer("10_1279529226.73787")
 .annotate 'line', 4
-    get_hll_global $P1372, ["NQP";"Regex"], "_block1371" 
-    capture_lex $P1372
-    .const 'Sub' $P1358 = "348_1278500537.15927" 
-    capture_lex $P1358
-    .const 'Sub' $P1352 = "346_1278500537.15927" 
-    capture_lex $P1352
-    .const 'Sub' $P1346 = "344_1278500537.15927" 
-    capture_lex $P1346
-    .const 'Sub' $P1340 = "342_1278500537.15927" 
+    get_hll_global $P1340, ["NQP";"Regex"], "_block1339" 
     capture_lex $P1340
-    .const 'Sub' $P1334 = "340_1278500537.15927" 
-    capture_lex $P1334
-    .const 'Sub' $P1328 = "338_1278500537.15927" 
-    capture_lex $P1328
-    .const 'Sub' $P1321 = "336_1278500537.15927" 
-    capture_lex $P1321
-    .const 'Sub' $P1314 = "334_1278500537.15927" 
+    .const 'Sub' $P1326 = "348_1279529226.73787" 
+    capture_lex $P1326
+    .const 'Sub' $P1320 = "346_1279529226.73787" 
+    capture_lex $P1320
+    .const 'Sub' $P1314 = "344_1279529226.73787" 
     capture_lex $P1314
-    .const 'Sub' $P1307 = "332_1278500537.15927" 
-    capture_lex $P1307
-    .const 'Sub' $P1300 = "330_1278500537.15927" 
-    capture_lex $P1300
-    .const 'Sub' $P1294 = "328_1278500537.15927" 
-    capture_lex $P1294
-    .const 'Sub' $P1287 = "326_1278500537.15927" 
-    capture_lex $P1287
-    .const 'Sub' $P1280 = "324_1278500537.15927" 
-    capture_lex $P1280
-    .const 'Sub' $P1273 = "322_1278500537.15927" 
-    capture_lex $P1273
-    .const 'Sub' $P1266 = "320_1278500537.15927" 
-    capture_lex $P1266
-    .const 'Sub' $P1259 = "318_1278500537.15927" 
-    capture_lex $P1259
-    .const 'Sub' $P1252 = "316_1278500537.15927" 
-    capture_lex $P1252
-    .const 'Sub' $P1245 = "314_1278500537.15927" 
-    capture_lex $P1245
-    .const 'Sub' $P1238 = "312_1278500537.15927" 
-    capture_lex $P1238
-    .const 'Sub' $P1231 = "310_1278500537.15927" 
-    capture_lex $P1231
-    .const 'Sub' $P1224 = "308_1278500537.15927" 
-    capture_lex $P1224
-    .const 'Sub' $P1217 = "306_1278500537.15927" 
-    capture_lex $P1217
-    .const 'Sub' $P1210 = "304_1278500537.15927" 
-    capture_lex $P1210
-    .const 'Sub' $P1203 = "302_1278500537.15927" 
-    capture_lex $P1203
-    .const 'Sub' $P1196 = "300_1278500537.15927" 
-    capture_lex $P1196
-    .const 'Sub' $P1189 = "298_1278500537.15927" 
-    capture_lex $P1189
-    .const 'Sub' $P1182 = "296_1278500537.15927" 
-    capture_lex $P1182
-    .const 'Sub' $P1175 = "294_1278500537.15927" 
-    capture_lex $P1175
-    .const 'Sub' $P1168 = "292_1278500537.15927" 
-    capture_lex $P1168
-    .const 'Sub' $P1161 = "290_1278500537.15927" 
-    capture_lex $P1161
-    .const 'Sub' $P1154 = "288_1278500537.15927" 
-    capture_lex $P1154
-    .const 'Sub' $P1147 = "286_1278500537.15927" 
-    capture_lex $P1147
-    .const 'Sub' $P1140 = "284_1278500537.15927" 
-    capture_lex $P1140
-    .const 'Sub' $P1133 = "282_1278500537.15927" 
-    capture_lex $P1133
-    .const 'Sub' $P1126 = "280_1278500537.15927" 
-    capture_lex $P1126
-    .const 'Sub' $P1119 = "278_1278500537.15927" 
-    capture_lex $P1119
-    .const 'Sub' $P1112 = "276_1278500537.15927" 
-    capture_lex $P1112
-    .const 'Sub' $P1105 = "274_1278500537.15927" 
-    capture_lex $P1105
-    .const 'Sub' $P1098 = "272_1278500537.15927" 
-    capture_lex $P1098
-    .const 'Sub' $P1091 = "270_1278500537.15927" 
-    capture_lex $P1091
-    .const 'Sub' $P1085 = "268_1278500537.15927" 
-    capture_lex $P1085
-    .const 'Sub' $P1078 = "266_1278500537.15927" 
-    capture_lex $P1078
-    .const 'Sub' $P1071 = "264_1278500537.15927" 
-    capture_lex $P1071
-    .const 'Sub' $P1064 = "262_1278500537.15927" 
-    capture_lex $P1064
-    .const 'Sub' $P1057 = "260_1278500537.15927" 
-    capture_lex $P1057
-    .const 'Sub' $P1050 = "258_1278500537.15927" 
-    capture_lex $P1050
-    .const 'Sub' $P1043 = "256_1278500537.15927" 
-    capture_lex $P1043
-    .const 'Sub' $P1036 = "254_1278500537.15927" 
-    capture_lex $P1036
-    .const 'Sub' $P1030 = "252_1278500537.15927" 
-    capture_lex $P1030
-    .const 'Sub' $P1024 = "250_1278500537.15927" 
-    capture_lex $P1024
-    .const 'Sub' $P1019 = "248_1278500537.15927" 
-    capture_lex $P1019
-    .const 'Sub' $P1013 = "246_1278500537.15927" 
-    capture_lex $P1013
-    .const 'Sub' $P1007 = "244_1278500537.15927" 
-    capture_lex $P1007
-    .const 'Sub' $P1002 = "242_1278500537.15927" 
-    capture_lex $P1002
-    .const 'Sub' $P997 = "240_1278500537.15927" 
-    capture_lex $P997
-    .const 'Sub' $P989 = "238_1278500537.15927" 
-    capture_lex $P989
-    .const 'Sub' $P981 = "236_1278500537.15927" 
+    .const 'Sub' $P1308 = "342_1279529226.73787" 
+    capture_lex $P1308
+    .const 'Sub' $P1302 = "340_1279529226.73787" 
+    capture_lex $P1302
+    .const 'Sub' $P1296 = "338_1279529226.73787" 
+    capture_lex $P1296
+    .const 'Sub' $P1289 = "336_1279529226.73787" 
+    capture_lex $P1289
+    .const 'Sub' $P1282 = "334_1279529226.73787" 
+    capture_lex $P1282
+    .const 'Sub' $P1275 = "332_1279529226.73787" 
+    capture_lex $P1275
+    .const 'Sub' $P1268 = "330_1279529226.73787" 
+    capture_lex $P1268
+    .const 'Sub' $P1262 = "328_1279529226.73787" 
+    capture_lex $P1262
+    .const 'Sub' $P1255 = "326_1279529226.73787" 
+    capture_lex $P1255
+    .const 'Sub' $P1248 = "324_1279529226.73787" 
+    capture_lex $P1248
+    .const 'Sub' $P1241 = "322_1279529226.73787" 
+    capture_lex $P1241
+    .const 'Sub' $P1234 = "320_1279529226.73787" 
+    capture_lex $P1234
+    .const 'Sub' $P1227 = "318_1279529226.73787" 
+    capture_lex $P1227
+    .const 'Sub' $P1220 = "316_1279529226.73787" 
+    capture_lex $P1220
+    .const 'Sub' $P1213 = "314_1279529226.73787" 
+    capture_lex $P1213
+    .const 'Sub' $P1206 = "312_1279529226.73787" 
+    capture_lex $P1206
+    .const 'Sub' $P1199 = "310_1279529226.73787" 
+    capture_lex $P1199
+    .const 'Sub' $P1192 = "308_1279529226.73787" 
+    capture_lex $P1192
+    .const 'Sub' $P1185 = "306_1279529226.73787" 
+    capture_lex $P1185
+    .const 'Sub' $P1178 = "304_1279529226.73787" 
+    capture_lex $P1178
+    .const 'Sub' $P1171 = "302_1279529226.73787" 
+    capture_lex $P1171
+    .const 'Sub' $P1164 = "300_1279529226.73787" 
+    capture_lex $P1164
+    .const 'Sub' $P1157 = "298_1279529226.73787" 
+    capture_lex $P1157
+    .const 'Sub' $P1150 = "296_1279529226.73787" 
+    capture_lex $P1150
+    .const 'Sub' $P1143 = "294_1279529226.73787" 
+    capture_lex $P1143
+    .const 'Sub' $P1136 = "292_1279529226.73787" 
+    capture_lex $P1136
+    .const 'Sub' $P1129 = "290_1279529226.73787" 
+    capture_lex $P1129
+    .const 'Sub' $P1122 = "288_1279529226.73787" 
+    capture_lex $P1122
+    .const 'Sub' $P1115 = "286_1279529226.73787" 
+    capture_lex $P1115
+    .const 'Sub' $P1108 = "284_1279529226.73787" 
+    capture_lex $P1108
+    .const 'Sub' $P1101 = "282_1279529226.73787" 
+    capture_lex $P1101
+    .const 'Sub' $P1094 = "280_1279529226.73787" 
+    capture_lex $P1094
+    .const 'Sub' $P1087 = "278_1279529226.73787" 
+    capture_lex $P1087
+    .const 'Sub' $P1080 = "276_1279529226.73787" 
+    capture_lex $P1080
+    .const 'Sub' $P1073 = "274_1279529226.73787" 
+    capture_lex $P1073
+    .const 'Sub' $P1066 = "272_1279529226.73787" 
+    capture_lex $P1066
+    .const 'Sub' $P1059 = "270_1279529226.73787" 
+    capture_lex $P1059
+    .const 'Sub' $P1053 = "268_1279529226.73787" 
+    capture_lex $P1053
+    .const 'Sub' $P1046 = "266_1279529226.73787" 
+    capture_lex $P1046
+    .const 'Sub' $P1039 = "264_1279529226.73787" 
+    capture_lex $P1039
+    .const 'Sub' $P1032 = "262_1279529226.73787" 
+    capture_lex $P1032
+    .const 'Sub' $P1025 = "260_1279529226.73787" 
+    capture_lex $P1025
+    .const 'Sub' $P1018 = "258_1279529226.73787" 
+    capture_lex $P1018
+    .const 'Sub' $P1011 = "256_1279529226.73787" 
+    capture_lex $P1011
+    .const 'Sub' $P1004 = "254_1279529226.73787" 
+    capture_lex $P1004
+    .const 'Sub' $P998 = "252_1279529226.73787" 
+    capture_lex $P998
+    .const 'Sub' $P992 = "250_1279529226.73787" 
+    capture_lex $P992
+    .const 'Sub' $P987 = "248_1279529226.73787" 
+    capture_lex $P987
+    .const 'Sub' $P981 = "246_1279529226.73787" 
     capture_lex $P981
-    .const 'Sub' $P976 = "234_1278500537.15927" 
-    capture_lex $P976
-    .const 'Sub' $P971 = "232_1278500537.15927" 
-    capture_lex $P971
-    .const 'Sub' $P966 = "230_1278500537.15927" 
-    capture_lex $P966
-    .const 'Sub' $P958 = "228_1278500537.15927" 
-    capture_lex $P958
-    .const 'Sub' $P950 = "226_1278500537.15927" 
-    capture_lex $P950
-    .const 'Sub' $P945 = "224_1278500537.15927" 
-    capture_lex $P945
-    .const 'Sub' $P940 = "222_1278500537.15927" 
-    capture_lex $P940
-    .const 'Sub' $P935 = "220_1278500537.15927" 
-    capture_lex $P935
-    .const 'Sub' $P929 = "218_1278500537.15927" 
-    capture_lex $P929
-    .const 'Sub' $P923 = "216_1278500537.15927" 
-    capture_lex $P923
-    .const 'Sub' $P917 = "214_1278500537.15927" 
+    .const 'Sub' $P975 = "244_1279529226.73787" 
+    capture_lex $P975
+    .const 'Sub' $P970 = "242_1279529226.73787" 
+    capture_lex $P970
+    .const 'Sub' $P965 = "240_1279529226.73787" 
+    capture_lex $P965
+    .const 'Sub' $P957 = "238_1279529226.73787" 
+    capture_lex $P957
+    .const 'Sub' $P948 = "236_1279529226.73787" 
+    capture_lex $P948
+    .const 'Sub' $P943 = "234_1279529226.73787" 
+    capture_lex $P943
+    .const 'Sub' $P938 = "232_1279529226.73787" 
+    capture_lex $P938
+    .const 'Sub' $P933 = "230_1279529226.73787" 
+    capture_lex $P933
+    .const 'Sub' $P925 = "228_1279529226.73787" 
+    capture_lex $P925
+    .const 'Sub' $P917 = "226_1279529226.73787" 
     capture_lex $P917
-    .const 'Sub' $P911 = "212_1278500537.15927" 
-    capture_lex $P911
-    .const 'Sub' $P905 = "210_1278500537.15927" 
-    capture_lex $P905
-    .const 'Sub' $P900 = "208_1278500537.15927" 
-    capture_lex $P900
-    .const 'Sub' $P895 = "206_1278500537.15927" 
-    capture_lex $P895
-    .const 'Sub' $P882 = "202_1278500537.15927" 
-    capture_lex $P882
-    .const 'Sub' $P874 = "200_1278500537.15927" 
-    capture_lex $P874
-    .const 'Sub' $P868 = "198_1278500537.15927" 
-    capture_lex $P868
-    .const 'Sub' $P861 = "196_1278500537.15927" 
-    capture_lex $P861
-    .const 'Sub' $P855 = "194_1278500537.15927" 
-    capture_lex $P855
-    .const 'Sub' $P847 = "192_1278500537.15927" 
-    capture_lex $P847
-    .const 'Sub' $P839 = "190_1278500537.15927" 
-    capture_lex $P839
-    .const 'Sub' $P833 = "188_1278500537.15927" 
-    capture_lex $P833
-    .const 'Sub' $P827 = "186_1278500537.15927" 
-    capture_lex $P827
-    .const 'Sub' $P812 = "182_1278500537.15927" 
-    capture_lex $P812
-    .const 'Sub' $P774 = "180_1278500537.15927" 
-    capture_lex $P774
-    .const 'Sub' $P765 = "178_1278500537.15927" 
-    capture_lex $P765
-    .const 'Sub' $P759 = "176_1278500537.15927" 
-    capture_lex $P759
-    .const 'Sub' $P749 = "174_1278500537.15927" 
-    capture_lex $P749
-    .const 'Sub' $P735 = "172_1278500537.15927" 
+    .const 'Sub' $P912 = "224_1279529226.73787" 
+    capture_lex $P912
+    .const 'Sub' $P907 = "222_1279529226.73787" 
+    capture_lex $P907
+    .const 'Sub' $P902 = "220_1279529226.73787" 
+    capture_lex $P902
+    .const 'Sub' $P896 = "218_1279529226.73787" 
+    capture_lex $P896
+    .const 'Sub' $P890 = "216_1279529226.73787" 
+    capture_lex $P890
+    .const 'Sub' $P884 = "214_1279529226.73787" 
+    capture_lex $P884
+    .const 'Sub' $P878 = "212_1279529226.73787" 
+    capture_lex $P878
+    .const 'Sub' $P872 = "210_1279529226.73787" 
+    capture_lex $P872
+    .const 'Sub' $P867 = "208_1279529226.73787" 
+    capture_lex $P867
+    .const 'Sub' $P862 = "206_1279529226.73787" 
+    capture_lex $P862
+    .const 'Sub' $P850 = "202_1279529226.73787" 
+    capture_lex $P850
+    .const 'Sub' $P842 = "200_1279529226.73787" 
+    capture_lex $P842
+    .const 'Sub' $P836 = "198_1279529226.73787" 
+    capture_lex $P836
+    .const 'Sub' $P829 = "196_1279529226.73787" 
+    capture_lex $P829
+    .const 'Sub' $P823 = "194_1279529226.73787" 
+    capture_lex $P823
+    .const 'Sub' $P815 = "192_1279529226.73787" 
+    capture_lex $P815
+    .const 'Sub' $P807 = "190_1279529226.73787" 
+    capture_lex $P807
+    .const 'Sub' $P801 = "188_1279529226.73787" 
+    capture_lex $P801
+    .const 'Sub' $P795 = "186_1279529226.73787" 
+    capture_lex $P795
+    .const 'Sub' $P781 = "182_1279529226.73787" 
+    capture_lex $P781
+    .const 'Sub' $P744 = "180_1279529226.73787" 
+    capture_lex $P744
+    .const 'Sub' $P735 = "178_1279529226.73787" 
     capture_lex $P735
-    .const 'Sub' $P726 = "170_1278500537.15927" 
-    capture_lex $P726
-    .const 'Sub' $P718 = "168_1278500537.15927" 
-    capture_lex $P718
-    .const 'Sub' $P708 = "166_1278500537.15927" 
-    capture_lex $P708
-    .const 'Sub' $P684 = "162_1278500537.15927" 
-    capture_lex $P684
-    .const 'Sub' $P659 = "160_1278500537.15927" 
-    capture_lex $P659
-    .const 'Sub' $P652 = "158_1278500537.15927" 
-    capture_lex $P652
-    .const 'Sub' $P645 = "156_1278500537.15927" 
-    capture_lex $P645
-    .const 'Sub' $P635 = "152_1278500537.15927" 
-    capture_lex $P635
-    .const 'Sub' $P627 = "150_1278500537.15927" 
+    .const 'Sub' $P729 = "176_1279529226.73787" 
+    capture_lex $P729
+    .const 'Sub' $P719 = "174_1279529226.73787" 
+    capture_lex $P719
+    .const 'Sub' $P706 = "172_1279529226.73787" 
+    capture_lex $P706
+    .const 'Sub' $P699 = "170_1279529226.73787" 
+    capture_lex $P699
+    .const 'Sub' $P691 = "168_1279529226.73787" 
+    capture_lex $P691
+    .const 'Sub' $P681 = "166_1279529226.73787" 
+    capture_lex $P681
+    .const 'Sub' $P657 = "162_1279529226.73787" 
+    capture_lex $P657
+    .const 'Sub' $P634 = "160_1279529226.73787" 
+    capture_lex $P634
+    .const 'Sub' $P627 = "158_1279529226.73787" 
     capture_lex $P627
-    .const 'Sub' $P621 = "148_1278500537.15927" 
-    capture_lex $P621
-    .const 'Sub' $P608 = "146_1278500537.15927" 
-    capture_lex $P608
-    .const 'Sub' $P601 = "144_1278500537.15927" 
-    capture_lex $P601
-    .const 'Sub' $P594 = "142_1278500537.15927" 
-    capture_lex $P594
-    .const 'Sub' $P587 = "140_1278500537.15927" 
-    capture_lex $P587
-    .const 'Sub' $P559 = "136_1278500537.15927" 
-    capture_lex $P559
-    .const 'Sub' $P550 = "134_1278500537.15927" 
-    capture_lex $P550
-    .const 'Sub' $P543 = "132_1278500537.15927" 
-    capture_lex $P543
-    .const 'Sub' $P534 = "128_1278500537.15927" 
-    capture_lex $P534
-    .const 'Sub' $P529 = "126_1278500537.15927" 
-    capture_lex $P529
-    .const 'Sub' $P517 = "124_1278500537.15927" 
-    capture_lex $P517
-    .const 'Sub' $P505 = "122_1278500537.15927" 
+    .const 'Sub' $P620 = "156_1279529226.73787" 
+    capture_lex $P620
+    .const 'Sub' $P610 = "152_1279529226.73787" 
+    capture_lex $P610
+    .const 'Sub' $P602 = "150_1279529226.73787" 
+    capture_lex $P602
+    .const 'Sub' $P596 = "148_1279529226.73787" 
+    capture_lex $P596
+    .const 'Sub' $P583 = "146_1279529226.73787" 
+    capture_lex $P583
+    .const 'Sub' $P576 = "144_1279529226.73787" 
+    capture_lex $P576
+    .const 'Sub' $P569 = "142_1279529226.73787" 
+    capture_lex $P569
+    .const 'Sub' $P562 = "140_1279529226.73787" 
+    capture_lex $P562
+    .const 'Sub' $P535 = "136_1279529226.73787" 
+    capture_lex $P535
+    .const 'Sub' $P526 = "134_1279529226.73787" 
+    capture_lex $P526
+    .const 'Sub' $P519 = "132_1279529226.73787" 
+    capture_lex $P519
+    .const 'Sub' $P510 = "128_1279529226.73787" 
+    capture_lex $P510
+    .const 'Sub' $P505 = "126_1279529226.73787" 
     capture_lex $P505
-    .const 'Sub' $P497 = "120_1278500537.15927" 
-    capture_lex $P497
-    .const 'Sub' $P492 = "118_1278500537.15927" 
-    capture_lex $P492
-    .const 'Sub' $P486 = "116_1278500537.15927" 
-    capture_lex $P486
-    .const 'Sub' $P480 = "114_1278500537.15927" 
-    capture_lex $P480
-    .const 'Sub' $P470 = "111_1278500537.15927" 
-    capture_lex $P470
-    .const 'Sub' $P464 = "109_1278500537.15927" 
-    capture_lex $P464
-    .const 'Sub' $P458 = "107_1278500537.15927" 
-    capture_lex $P458
-    .const 'Sub' $P452 = "105_1278500537.15927" 
-    capture_lex $P452
-    .const 'Sub' $P446 = "103_1278500537.15927" 
-    capture_lex $P446
-    .const 'Sub' $P440 = "101_1278500537.15927" 
-    capture_lex $P440
-    .const 'Sub' $P434 = "99_1278500537.15927" 
-    capture_lex $P434
-    .const 'Sub' $P425 = "97_1278500537.15927" 
-    capture_lex $P425
-    .const 'Sub' $P416 = "95_1278500537.15927" 
-    capture_lex $P416
-    .const 'Sub' $P407 = "93_1278500537.15927" 
-    capture_lex $P407
-    .const 'Sub' $P394 = "89_1278500537.15927" 
-    capture_lex $P394
-    .const 'Sub' $P385 = "87_1278500537.15927" 
-    capture_lex $P385
-    .const 'Sub' $P375 = "83_1278500537.15927" 
-    capture_lex $P375
-    .const 'Sub' $P368 = "81_1278500537.15927" 
-    capture_lex $P368
-    .const 'Sub' $P361 = "79_1278500537.15927" 
-    capture_lex $P361
-    .const 'Sub' $P349 = "75_1278500537.15927" 
-    capture_lex $P349
-    .const 'Sub' $P341 = "73_1278500537.15927" 
-    capture_lex $P341
-    .const 'Sub' $P333 = "71_1278500537.15927" 
-    capture_lex $P333
-    .const 'Sub' $P313 = "69_1278500537.15927" 
-    capture_lex $P313
-    .const 'Sub' $P304 = "67_1278500537.15927" 
-    capture_lex $P304
-    .const 'Sub' $P286 = "64_1278500537.15927" 
-    capture_lex $P286
-    .const 'Sub' $P266 = "62_1278500537.15927" 
-    capture_lex $P266
-    .const 'Sub' $P257 = "58_1278500537.15927" 
-    capture_lex $P257
-    .const 'Sub' $P252 = "56_1278500537.15927" 
-    capture_lex $P252
-    .const 'Sub' $P243 = "52_1278500537.15927" 
-    capture_lex $P243
-    .const 'Sub' $P238 = "50_1278500537.15927" 
-    capture_lex $P238
-    .const 'Sub' $P233 = "48_1278500537.15927" 
-    capture_lex $P233
-    .const 'Sub' $P225 = "46_1278500537.15927" 
-    capture_lex $P225
-    .const 'Sub' $P218 = "44_1278500537.15927" 
-    capture_lex $P218
-    .const 'Sub' $P212 = "42_1278500537.15927" 
+    .const 'Sub' $P493 = "124_1279529226.73787" 
+    capture_lex $P493
+    .const 'Sub' $P481 = "122_1279529226.73787" 
+    capture_lex $P481
+    .const 'Sub' $P474 = "120_1279529226.73787" 
+    capture_lex $P474
+    .const 'Sub' $P469 = "118_1279529226.73787" 
+    capture_lex $P469
+    .const 'Sub' $P463 = "116_1279529226.73787" 
+    capture_lex $P463
+    .const 'Sub' $P457 = "114_1279529226.73787" 
+    capture_lex $P457
+    .const 'Sub' $P447 = "111_1279529226.73787" 
+    capture_lex $P447
+    .const 'Sub' $P441 = "109_1279529226.73787" 
+    capture_lex $P441
+    .const 'Sub' $P435 = "107_1279529226.73787" 
+    capture_lex $P435
+    .const 'Sub' $P429 = "105_1279529226.73787" 
+    capture_lex $P429
+    .const 'Sub' $P423 = "103_1279529226.73787" 
+    capture_lex $P423
+    .const 'Sub' $P417 = "101_1279529226.73787" 
+    capture_lex $P417
+    .const 'Sub' $P411 = "99_1279529226.73787" 
+    capture_lex $P411
+    .const 'Sub' $P402 = "97_1279529226.73787" 
+    capture_lex $P402
+    .const 'Sub' $P393 = "95_1279529226.73787" 
+    capture_lex $P393
+    .const 'Sub' $P384 = "93_1279529226.73787" 
+    capture_lex $P384
+    .const 'Sub' $P371 = "89_1279529226.73787" 
+    capture_lex $P371
+    .const 'Sub' $P362 = "87_1279529226.73787" 
+    capture_lex $P362
+    .const 'Sub' $P352 = "83_1279529226.73787" 
+    capture_lex $P352
+    .const 'Sub' $P345 = "81_1279529226.73787" 
+    capture_lex $P345
+    .const 'Sub' $P338 = "79_1279529226.73787" 
+    capture_lex $P338
+    .const 'Sub' $P326 = "75_1279529226.73787" 
+    capture_lex $P326
+    .const 'Sub' $P318 = "73_1279529226.73787" 
+    capture_lex $P318
+    .const 'Sub' $P310 = "71_1279529226.73787" 
+    capture_lex $P310
+    .const 'Sub' $P290 = "69_1279529226.73787" 
+    capture_lex $P290
+    .const 'Sub' $P281 = "67_1279529226.73787" 
+    capture_lex $P281
+    .const 'Sub' $P263 = "64_1279529226.73787" 
+    capture_lex $P263
+    .const 'Sub' $P245 = "62_1279529226.73787" 
+    capture_lex $P245
+    .const 'Sub' $P236 = "58_1279529226.73787" 
+    capture_lex $P236
+    .const 'Sub' $P231 = "56_1279529226.73787" 
+    capture_lex $P231
+    .const 'Sub' $P222 = "52_1279529226.73787" 
+    capture_lex $P222
+    .const 'Sub' $P217 = "50_1279529226.73787" 
+    capture_lex $P217
+    .const 'Sub' $P212 = "48_1279529226.73787" 
     capture_lex $P212
-    .const 'Sub' $P204 = "40_1278500537.15927" 
-    capture_lex $P204
-    .const 'Sub' $P198 = "38_1278500537.15927" 
-    capture_lex $P198
-    .const 'Sub' $P192 = "36_1278500537.15927" 
-    capture_lex $P192
-    .const 'Sub' $P176 = "33_1278500537.15927" 
+    .const 'Sub' $P203 = "46_1279529226.73787" 
+    capture_lex $P203
+    .const 'Sub' $P196 = "44_1279529226.73787" 
+    capture_lex $P196
+    .const 'Sub' $P190 = "42_1279529226.73787" 
+    capture_lex $P190
+    .const 'Sub' $P182 = "40_1279529226.73787" 
+    capture_lex $P182
+    .const 'Sub' $P176 = "38_1279529226.73787" 
     capture_lex $P176
-    .const 'Sub' $P161 = "31_1278500537.15927" 
-    capture_lex $P161
-    .const 'Sub' $P154 = "29_1278500537.15927" 
-    capture_lex $P154
-    .const 'Sub' $P104 = "26_1278500537.15927" 
-    capture_lex $P104
-    .const 'Sub' $P86 = "23_1278500537.15927" 
-    capture_lex $P86
-    .const 'Sub' $P72 = "21_1278500537.15927" 
-    capture_lex $P72
-    .const 'Sub' $P58 = "19_1278500537.15927" 
-    capture_lex $P58
-    .const 'Sub' $P50 = "17_1278500537.15927" 
-    capture_lex $P50
-    .const 'Sub' $P43 = "15_1278500537.15927" 
-    capture_lex $P43
-    .const 'Sub' $P35 = "13_1278500537.15927" 
+    .const 'Sub' $P170 = "36_1279529226.73787" 
+    capture_lex $P170
+    .const 'Sub' $P155 = "33_1279529226.73787" 
+    capture_lex $P155
+    .const 'Sub' $P141 = "31_1279529226.73787" 
+    capture_lex $P141
+    .const 'Sub' $P134 = "29_1279529226.73787" 
+    capture_lex $P134
+    .const 'Sub' $P95 = "26_1279529226.73787" 
+    capture_lex $P95
+    .const 'Sub' $P80 = "23_1279529226.73787" 
+    capture_lex $P80
+    .const 'Sub' $P69 = "21_1279529226.73787" 
+    capture_lex $P69
+    .const 'Sub' $P57 = "19_1279529226.73787" 
+    capture_lex $P57
+    .const 'Sub' $P49 = "17_1279529226.73787" 
+    capture_lex $P49
+    .const 'Sub' $P42 = "15_1279529226.73787" 
+    capture_lex $P42
+    .const 'Sub' $P35 = "13_1279529226.73787" 
     capture_lex $P35
-    .const 'Sub' $P15 = "12_1278500537.15927" 
+    .const 'Sub' $P15 = "12_1279529226.73787" 
     capture_lex $P15
     $P0 = find_dynamic_lex "$*CTXSAVE"
     if null $P0 goto ctxsave_done
@@ -372,76 +372,76 @@
     $P0."ctxsave"()
   ctxsave_done:
 .annotate 'line', 567
-    get_hll_global $P1372, ["NQP";"Regex"], "_block1371" 
-    capture_lex $P1372
-    $P1435 = $P1372()
+    get_hll_global $P1340, ["NQP";"Regex"], "_block1339" 
+    capture_lex $P1340
+    $P1402 = $P1340()
 .annotate 'line', 4
-    .return ($P1435)
-    .const 'Sub' $P1437 = "370_1278500537.15927" 
-    .return ($P1437)
+    .return ($P1402)
+    .const 'Sub' $P1404 = "370_1279529226.73787" 
+    .return ($P1404)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "" :load :init :subid("post373") :outer("11_1278500537.15927")
+.sub "" :load :init :subid("post373") :outer("11_1279529226.73787")
 .annotate 'line', 4
     get_hll_global $P14, ["NQP";"Grammar"], "_block13" 
     .local pmc block
     set block, $P14
 .annotate 'line', 448
-    get_hll_global $P1440, ["NQP"], "Grammar"
-    $P1440."O"(":prec<y=>, :assoc<unary>", "%methodop")
+    get_hll_global $P1407, ["NQP"], "Grammar"
+    $P1407."O"(":prec<y=>, :assoc<unary>", "%methodop")
 .annotate 'line', 449
-    get_hll_global $P1441, ["NQP"], "Grammar"
-    $P1441."O"(":prec<x=>, :assoc<unary>", "%autoincrement")
+    get_hll_global $P1408, ["NQP"], "Grammar"
+    $P1408."O"(":prec<x=>, :assoc<unary>", "%autoincrement")
 .annotate 'line', 450
-    get_hll_global $P1442, ["NQP"], "Grammar"
-    $P1442."O"(":prec<w=>, :assoc<left>", "%exponentiation")
+    get_hll_global $P1409, ["NQP"], "Grammar"
+    $P1409."O"(":prec<w=>, :assoc<left>", "%exponentiation")
 .annotate 'line', 451
-    get_hll_global $P1443, ["NQP"], "Grammar"
-    $P1443."O"(":prec<v=>, :assoc<unary>", "%symbolic_unary")
+    get_hll_global $P1410, ["NQP"], "Grammar"
+    $P1410."O"(":prec<v=>, :assoc<unary>", "%symbolic_unary")
 .annotate 'line', 452
-    get_hll_global $P1444, ["NQP"], "Grammar"
-    $P1444."O"(":prec<u=>, :assoc<left>", "%multiplicative")
+    get_hll_global $P1411, ["NQP"], "Grammar"
+    $P1411."O"(":prec<u=>, :assoc<left>", "%multiplicative")
 .annotate 'line', 453
-    get_hll_global $P1445, ["NQP"], "Grammar"
-    $P1445."O"(":prec<t=>, :assoc<left>", "%additive")
+    get_hll_global $P1412, ["NQP"], "Grammar"
+    $P1412."O"(":prec<t=>, :assoc<left>", "%additive")
 .annotate 'line', 454
-    get_hll_global $P1446, ["NQP"], "Grammar"
-    $P1446."O"(":prec<r=>, :assoc<left>", "%concatenation")
+    get_hll_global $P1413, ["NQP"], "Grammar"
+    $P1413."O"(":prec<r=>, :assoc<left>", "%concatenation")
 .annotate 'line', 455
-    get_hll_global $P1447, ["NQP"], "Grammar"
-    $P1447."O"(":prec<m=>, :assoc<left>", "%relational")
+    get_hll_global $P1414, ["NQP"], "Grammar"
+    $P1414."O"(":prec<m=>, :assoc<left>", "%relational")
 .annotate 'line', 456
-    get_hll_global $P1448, ["NQP"], "Grammar"
-    $P1448."O"(":prec<l=>, :assoc<left>", "%tight_and")
+    get_hll_global $P1415, ["NQP"], "Grammar"
+    $P1415."O"(":prec<l=>, :assoc<left>", "%tight_and")
 .annotate 'line', 457
-    get_hll_global $P1449, ["NQP"], "Grammar"
-    $P1449."O"(":prec<k=>, :assoc<left>", "%tight_or")
+    get_hll_global $P1416, ["NQP"], "Grammar"
+    $P1416."O"(":prec<k=>, :assoc<left>", "%tight_or")
 .annotate 'line', 458
-    get_hll_global $P1450, ["NQP"], "Grammar"
-    $P1450."O"(":prec<j=>, :assoc<right>", "%conditional")
+    get_hll_global $P1417, ["NQP"], "Grammar"
+    $P1417."O"(":prec<j=>, :assoc<right>", "%conditional")
 .annotate 'line', 459
-    get_hll_global $P1451, ["NQP"], "Grammar"
-    $P1451."O"(":prec<i=>, :assoc<right>", "%assignment")
+    get_hll_global $P1418, ["NQP"], "Grammar"
+    $P1418."O"(":prec<i=>, :assoc<right>", "%assignment")
 .annotate 'line', 460
-    get_hll_global $P1452, ["NQP"], "Grammar"
-    $P1452."O"(":prec<g=>, :assoc<list>, :nextterm<nulltermish>", "%comma")
+    get_hll_global $P1419, ["NQP"], "Grammar"
+    $P1419."O"(":prec<g=>, :assoc<list>, :nextterm<nulltermish>", "%comma")
 .annotate 'line', 461
-    get_hll_global $P1453, ["NQP"], "Grammar"
-    $P1453."O"(":prec<f=>, :assoc<list>", "%list_infix")
+    get_hll_global $P1420, ["NQP"], "Grammar"
+    $P1420."O"(":prec<f=>, :assoc<list>", "%list_infix")
 .annotate 'line', 462
-    get_hll_global $P1454, ["NQP"], "Grammar"
-    $P1454."O"(":prec<e=>, :assoc<unary>", "%list_prefix")
+    get_hll_global $P1421, ["NQP"], "Grammar"
+    $P1421."O"(":prec<e=>, :assoc<unary>", "%list_prefix")
 .annotate 'line', 447
-    $P1455 = get_root_global ["parrot"], "P6metaclass"
-    $P1455."new_class"("NQP::Regex", "Regex::P6Regex::Grammar" :named("parent"))
+    $P1422 = get_root_global ["parrot"], "P6metaclass"
+    $P1422."new_class"("NQP::Regex", "Regex::P6Regex::Grammar" :named("parent"))
 .end
 
 
 .namespace ["NQP";"Grammar"]
 .include "except_types.pasm"
-.sub "TOP"  :subid("12_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "TOP"  :subid("12_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
     new $P17, 'ExceptionHandler'
     set_addr $P17, control_16
@@ -531,7 +531,7 @@
 
 
 .namespace ["NQP";"Grammar"]
-.sub "identifier"  :subid("13_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "identifier"  :subid("13_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
     .local string rx36_tgt
     .local int rx36_pos
@@ -539,8 +539,7 @@
     .local int rx36_eos
     .local int rx36_rep
     .local pmc rx36_cur
-    (rx36_cur, rx36_pos, rx36_tgt) = self."!cursor_start"()
-    rx36_cur."!cursor_debug"("START ", "identifier")
+    (rx36_cur, rx36_pos, rx36_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx36_cur
     .local pmc match
     .lex "$/", match
@@ -551,6 +550,8 @@
     sub rx36_off, rx36_pos, 1
     substr rx36_tgt, rx36_tgt, rx36_off
   rx36_start:
+    eq $I10, 1, rx36_restart
+    rx36_cur."!cursor_debug"("START ", "identifier")
     $I10 = self.'from'()
     ne $I10, -1, rxscan40_done
     goto rxscan40_scan
@@ -570,8 +571,8 @@
     unless $P10, rx36_fail
     rx36_pos = $P10."pos"()
   # rx rxquantr41 ** 0..*
-    set_addr $I42, rxquantr41_done
-    rx36_cur."!mark_push"(0, rx36_pos, $I42)
+    set_addr $I10, rxquantr41_done
+    rx36_cur."!mark_push"(0, rx36_pos, $I10)
   rxquantr41_loop:
   # rx enumcharlist negate=0 
     ge rx36_pos, rx36_eos, rx36_fail
@@ -585,16 +586,20 @@
     $P10 = rx36_cur."ident"()
     unless $P10, rx36_fail
     rx36_pos = $P10."pos"()
-    (rx36_rep) = rx36_cur."!mark_commit"($I42)
-    rx36_cur."!mark_push"(rx36_rep, rx36_pos, $I42)
+    set_addr $I10, rxquantr41_done
+    (rx36_rep) = rx36_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr41_done
+    rx36_cur."!mark_push"(rx36_rep, rx36_pos, $I10)
     goto rxquantr41_loop
   rxquantr41_done:
   # rx pass
     rx36_cur."!cursor_pass"(rx36_pos, "identifier")
     rx36_cur."!cursor_debug"("PASS  ", "identifier", " at pos=", rx36_pos)
     .return (rx36_cur)
-  rx36_fail:
+  rx36_restart:
 .annotate 'line', 4
+    rx36_cur."!cursor_debug"("NEXT ", "identifier")
+  rx36_fail:
     (rx36_rep, rx36_pos, $I10, $P10) = rx36_cur."!mark_fail"(0)
     lt rx36_pos, -1, rx36_done
     eq rx36_pos, -1, rx36_fail
@@ -608,7 +613,7 @@
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__identifier"  :subid("14_1278500537.15927") :method
+.sub "!PREFIX__identifier"  :subid("14_1279529226.73787") :method
 .annotate 'line', 4
     $P38 = self."!PREFIX__!subrule"("ident", "")
     new $P39, "ResizablePMCArray"
@@ -618,1488 +623,1861 @@
 
 
 .namespace ["NQP";"Grammar"]
-.sub "name"  :subid("15_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "name"  :subid("15_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx44_tgt
-    .local int rx44_pos
-    .local int rx44_off
-    .local int rx44_eos
-    .local int rx44_rep
-    .local pmc rx44_cur
-    (rx44_cur, rx44_pos, rx44_tgt) = self."!cursor_start"()
-    rx44_cur."!cursor_debug"("START ", "name")
-    rx44_cur."!cursor_caparray"("identifier")
-    .lex unicode:"$\x{a2}", rx44_cur
-    .local pmc match
-    .lex "$/", match
-    length rx44_eos, rx44_tgt
-    gt rx44_pos, rx44_eos, rx44_done
-    set rx44_off, 0
-    lt rx44_pos, 2, rx44_start
-    sub rx44_off, rx44_pos, 1
-    substr rx44_tgt, rx44_tgt, rx44_off
-  rx44_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan47_done
-    goto rxscan47_scan
-  rxscan47_loop:
-    ($P10) = rx44_cur."from"()
-    inc $P10
-    set rx44_pos, $P10
-    ge rx44_pos, rx44_eos, rxscan47_done
-  rxscan47_scan:
-    set_addr $I10, rxscan47_loop
-    rx44_cur."!mark_push"(0, rx44_pos, $I10)
-  rxscan47_done:
+    .local string rx43_tgt
+    .local int rx43_pos
+    .local int rx43_off
+    .local int rx43_eos
+    .local int rx43_rep
+    .local pmc rx43_cur
+    (rx43_cur, rx43_pos, rx43_tgt, $I10) = self."!cursor_start"()
+    rx43_cur."!cursor_caparray"("identifier")
+    .lex unicode:"$\x{a2}", rx43_cur
+    .local pmc match
+    .lex "$/", match
+    length rx43_eos, rx43_tgt
+    gt rx43_pos, rx43_eos, rx43_done
+    set rx43_off, 0
+    lt rx43_pos, 2, rx43_start
+    sub rx43_off, rx43_pos, 1
+    substr rx43_tgt, rx43_tgt, rx43_off
+  rx43_start:
+    eq $I10, 1, rx43_restart
+    rx43_cur."!cursor_debug"("START ", "name")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan46_done
+    goto rxscan46_scan
+  rxscan46_loop:
+    ($P10) = rx43_cur."from"()
+    inc $P10
+    set rx43_pos, $P10
+    ge rx43_pos, rx43_eos, rxscan46_done
+  rxscan46_scan:
+    set_addr $I10, rxscan46_loop
+    rx43_cur."!mark_push"(0, rx43_pos, $I10)
+  rxscan46_done:
 .annotate 'line', 19
-  # rx rxquantr48 ** 1..*
-    set_addr $I49, rxquantr48_done
-    rx44_cur."!mark_push"(0, -1, $I49)
-  rxquantr48_loop:
+  # rx rxquantr47 ** 1..*
+    set_addr $I10, rxquantr47_done
+    rx43_cur."!mark_push"(0, -1, $I10)
+  rxquantr47_loop:
   # rx subrule "identifier" subtype=capture negate=
-    rx44_cur."!cursor_pos"(rx44_pos)
-    $P10 = rx44_cur."identifier"()
-    unless $P10, rx44_fail
-    rx44_cur."!mark_push"(0, -1, 0, $P10)
+    rx43_cur."!cursor_pos"(rx43_pos)
+    $P10 = rx43_cur."identifier"()
+    unless $P10, rx43_fail
+    goto rxsubrule48_pass
+  rxsubrule48_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx43_fail
+  rxsubrule48_pass:
+    set_addr $I10, rxsubrule48_back
+    rx43_cur."!mark_push"(0, rx43_pos, $I10, $P10)
     $P10."!cursor_names"("identifier")
-    rx44_pos = $P10."pos"()
-    (rx44_rep) = rx44_cur."!mark_commit"($I49)
-    rx44_cur."!mark_push"(rx44_rep, rx44_pos, $I49)
+    rx43_pos = $P10."pos"()
+    set_addr $I10, rxquantr47_done
+    (rx43_rep) = rx43_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr47_done
+    rx43_cur."!mark_push"(rx43_rep, rx43_pos, $I10)
   # rx literal  "::"
-    add $I11, rx44_pos, 2
-    gt $I11, rx44_eos, rx44_fail
-    sub $I11, rx44_pos, rx44_off
-    substr $S10, rx44_tgt, $I11, 2
-    ne $S10, "::", rx44_fail
-    add rx44_pos, 2
-    goto rxquantr48_loop
-  rxquantr48_done:
-  # rx pass
-    rx44_cur."!cursor_pass"(rx44_pos, "name")
-    rx44_cur."!cursor_debug"("PASS  ", "name", " at pos=", rx44_pos)
-    .return (rx44_cur)
-  rx44_fail:
-.annotate 'line', 4
-    (rx44_rep, rx44_pos, $I10, $P10) = rx44_cur."!mark_fail"(0)
-    lt rx44_pos, -1, rx44_done
-    eq rx44_pos, -1, rx44_fail
-    jump $I10
-  rx44_done:
-    rx44_cur."!cursor_fail"()
-    rx44_cur."!cursor_debug"("FAIL  ", "name")
-    .return (rx44_cur)
+    add $I11, rx43_pos, 2
+    gt $I11, rx43_eos, rx43_fail
+    sub $I11, rx43_pos, rx43_off
+    substr $S10, rx43_tgt, $I11, 2
+    ne $S10, "::", rx43_fail
+    add rx43_pos, 2
+    goto rxquantr47_loop
+  rxquantr47_done:
+  # rx pass
+    rx43_cur."!cursor_pass"(rx43_pos, "name")
+    rx43_cur."!cursor_debug"("PASS  ", "name", " at pos=", rx43_pos)
+    .return (rx43_cur)
+  rx43_restart:
+.annotate 'line', 4
+    rx43_cur."!cursor_debug"("NEXT ", "name")
+  rx43_fail:
+    (rx43_rep, rx43_pos, $I10, $P10) = rx43_cur."!mark_fail"(0)
+    lt rx43_pos, -1, rx43_done
+    eq rx43_pos, -1, rx43_fail
+    jump $I10
+  rx43_done:
+    rx43_cur."!cursor_fail"()
+    rx43_cur."!cursor_debug"("FAIL  ", "name")
+    .return (rx43_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__name"  :subid("16_1278500537.15927") :method
-.annotate 'line', 4
-    new $P46, "ResizablePMCArray"
-    push $P46, ""
-    .return ($P46)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "deflongname"  :subid("17_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx51_tgt
-    .local int rx51_pos
-    .local int rx51_off
-    .local int rx51_eos
-    .local int rx51_rep
-    .local pmc rx51_cur
-    (rx51_cur, rx51_pos, rx51_tgt) = self."!cursor_start"()
-    rx51_cur."!cursor_debug"("START ", "deflongname")
-    rx51_cur."!cursor_caparray"("colonpair")
-    .lex unicode:"$\x{a2}", rx51_cur
-    .local pmc match
-    .lex "$/", match
-    length rx51_eos, rx51_tgt
-    gt rx51_pos, rx51_eos, rx51_done
-    set rx51_off, 0
-    lt rx51_pos, 2, rx51_start
-    sub rx51_off, rx51_pos, 1
-    substr rx51_tgt, rx51_tgt, rx51_off
-  rx51_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan55_done
-    goto rxscan55_scan
-  rxscan55_loop:
-    ($P10) = rx51_cur."from"()
-    inc $P10
-    set rx51_pos, $P10
-    ge rx51_pos, rx51_eos, rxscan55_done
-  rxscan55_scan:
-    set_addr $I10, rxscan55_loop
-    rx51_cur."!mark_push"(0, rx51_pos, $I10)
-  rxscan55_done:
+.sub "!PREFIX__name"  :subid("16_1279529226.73787") :method
+.annotate 'line', 4
+    new $P45, "ResizablePMCArray"
+    push $P45, ""
+    .return ($P45)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "deflongname"  :subid("17_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx50_tgt
+    .local int rx50_pos
+    .local int rx50_off
+    .local int rx50_eos
+    .local int rx50_rep
+    .local pmc rx50_cur
+    (rx50_cur, rx50_pos, rx50_tgt, $I10) = self."!cursor_start"()
+    rx50_cur."!cursor_caparray"("colonpair")
+    .lex unicode:"$\x{a2}", rx50_cur
+    .local pmc match
+    .lex "$/", match
+    length rx50_eos, rx50_tgt
+    gt rx50_pos, rx50_eos, rx50_done
+    set rx50_off, 0
+    lt rx50_pos, 2, rx50_start
+    sub rx50_off, rx50_pos, 1
+    substr rx50_tgt, rx50_tgt, rx50_off
+  rx50_start:
+    eq $I10, 1, rx50_restart
+    rx50_cur."!cursor_debug"("START ", "deflongname")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan54_done
+    goto rxscan54_scan
+  rxscan54_loop:
+    ($P10) = rx50_cur."from"()
+    inc $P10
+    set rx50_pos, $P10
+    ge rx50_pos, rx50_eos, rxscan54_done
+  rxscan54_scan:
+    set_addr $I10, rxscan54_loop
+    rx50_cur."!mark_push"(0, rx50_pos, $I10)
+  rxscan54_done:
 .annotate 'line', 22
   # rx subrule "identifier" subtype=capture negate=
-    rx51_cur."!cursor_pos"(rx51_pos)
-    $P10 = rx51_cur."identifier"()
-    unless $P10, rx51_fail
-    rx51_cur."!mark_push"(0, -1, 0, $P10)
+    rx50_cur."!cursor_pos"(rx50_pos)
+    $P10 = rx50_cur."identifier"()
+    unless $P10, rx50_fail
+    rx50_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("identifier")
-    rx51_pos = $P10."pos"()
-  # rx rxquantr56 ** 0..1
-    set_addr $I57, rxquantr56_done
-    rx51_cur."!mark_push"(0, rx51_pos, $I57)
-  rxquantr56_loop:
+    rx50_pos = $P10."pos"()
+  # rx rxquantr55 ** 0..1
+    set_addr $I10, rxquantr55_done
+    rx50_cur."!mark_push"(0, rx50_pos, $I10)
+  rxquantr55_loop:
   # rx subrule "colonpair" subtype=capture negate=
-    rx51_cur."!cursor_pos"(rx51_pos)
-    $P10 = rx51_cur."colonpair"()
-    unless $P10, rx51_fail
-    rx51_cur."!mark_push"(0, -1, 0, $P10)
+    rx50_cur."!cursor_pos"(rx50_pos)
+    $P10 = rx50_cur."colonpair"()
+    unless $P10, rx50_fail
+    goto rxsubrule56_pass
+  rxsubrule56_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx50_fail
+  rxsubrule56_pass:
+    set_addr $I10, rxsubrule56_back
+    rx50_cur."!mark_push"(0, rx50_pos, $I10, $P10)
     $P10."!cursor_names"("colonpair")
-    rx51_pos = $P10."pos"()
-    (rx51_rep) = rx51_cur."!mark_commit"($I57)
-  rxquantr56_done:
+    rx50_pos = $P10."pos"()
+    set_addr $I10, rxquantr55_done
+    (rx50_rep) = rx50_cur."!mark_commit"($I10)
+  rxquantr55_done:
 .annotate 'line', 21
   # rx pass
-    rx51_cur."!cursor_pass"(rx51_pos, "deflongname")
-    rx51_cur."!cursor_debug"("PASS  ", "deflongname", " at pos=", rx51_pos)
-    .return (rx51_cur)
-  rx51_fail:
+    rx50_cur."!cursor_pass"(rx50_pos, "deflongname")
+    rx50_cur."!cursor_debug"("PASS  ", "deflongname", " at pos=", rx50_pos)
+    .return (rx50_cur)
+  rx50_restart:
 .annotate 'line', 4
-    (rx51_rep, rx51_pos, $I10, $P10) = rx51_cur."!mark_fail"(0)
-    lt rx51_pos, -1, rx51_done
-    eq rx51_pos, -1, rx51_fail
+    rx50_cur."!cursor_debug"("NEXT ", "deflongname")
+  rx50_fail:
+    (rx50_rep, rx50_pos, $I10, $P10) = rx50_cur."!mark_fail"(0)
+    lt rx50_pos, -1, rx50_done
+    eq rx50_pos, -1, rx50_fail
     jump $I10
-  rx51_done:
-    rx51_cur."!cursor_fail"()
-    rx51_cur."!cursor_debug"("FAIL  ", "deflongname")
-    .return (rx51_cur)
+  rx50_done:
+    rx50_cur."!cursor_fail"()
+    rx50_cur."!cursor_debug"("FAIL  ", "deflongname")
+    .return (rx50_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__deflongname"  :subid("18_1278500537.15927") :method
+.sub "!PREFIX__deflongname"  :subid("18_1279529226.73787") :method
 .annotate 'line', 4
-    $P53 = self."!PREFIX__!subrule"("identifier", "")
-    new $P54, "ResizablePMCArray"
-    push $P54, $P53
-    .return ($P54)
+    $P52 = self."!PREFIX__!subrule"("identifier", "")
+    new $P53, "ResizablePMCArray"
+    push $P53, $P52
+    .return ($P53)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "ENDSTMT"  :subid("19_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "ENDSTMT"  :subid("19_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx59_tgt
-    .local int rx59_pos
-    .local int rx59_off
-    .local int rx59_eos
-    .local int rx59_rep
-    .local pmc rx59_cur
-    (rx59_cur, rx59_pos, rx59_tgt) = self."!cursor_start"()
-    rx59_cur."!cursor_debug"("START ", "ENDSTMT")
-    .lex unicode:"$\x{a2}", rx59_cur
+    .local string rx58_tgt
+    .local int rx58_pos
+    .local int rx58_off
+    .local int rx58_eos
+    .local int rx58_rep
+    .local pmc rx58_cur
+    (rx58_cur, rx58_pos, rx58_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx58_cur
     .local pmc match
     .lex "$/", match
-    length rx59_eos, rx59_tgt
-    gt rx59_pos, rx59_eos, rx59_done
-    set rx59_off, 0
-    lt rx59_pos, 2, rx59_start
-    sub rx59_off, rx59_pos, 1
-    substr rx59_tgt, rx59_tgt, rx59_off
-  rx59_start:
+    length rx58_eos, rx58_tgt
+    gt rx58_pos, rx58_eos, rx58_done
+    set rx58_off, 0
+    lt rx58_pos, 2, rx58_start
+    sub rx58_off, rx58_pos, 1
+    substr rx58_tgt, rx58_tgt, rx58_off
+  rx58_start:
+    eq $I10, 1, rx58_restart
+    rx58_cur."!cursor_debug"("START ", "ENDSTMT")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan62_done
-    goto rxscan62_scan
-  rxscan62_loop:
-    ($P10) = rx59_cur."from"()
+    ne $I10, -1, rxscan61_done
+    goto rxscan61_scan
+  rxscan61_loop:
+    ($P10) = rx58_cur."from"()
     inc $P10
-    set rx59_pos, $P10
-    ge rx59_pos, rx59_eos, rxscan62_done
-  rxscan62_scan:
-    set_addr $I10, rxscan62_loop
-    rx59_cur."!mark_push"(0, rx59_pos, $I10)
-  rxscan62_done:
+    set rx58_pos, $P10
+    ge rx58_pos, rx58_eos, rxscan61_done
+  rxscan61_scan:
+    set_addr $I10, rxscan61_loop
+    rx58_cur."!mark_push"(0, rx58_pos, $I10)
+  rxscan61_done:
 .annotate 'line', 29
-  # rx rxquantr63 ** 0..1
-    set_addr $I71, rxquantr63_done
-    rx59_cur."!mark_push"(0, rx59_pos, $I71)
-  rxquantr63_loop:
-  alt64_0:
+  # rx rxquantr62 ** 0..1
+    set_addr $I10, rxquantr62_done
+    rx58_cur."!mark_push"(0, rx58_pos, $I10)
+  rxquantr62_loop:
+  alt63_0:
 .annotate 'line', 26
-    set_addr $I10, alt64_1
-    rx59_cur."!mark_push"(0, rx59_pos, $I10)
+    set_addr $I10, alt63_1
+    rx58_cur."!mark_push"(0, rx58_pos, $I10)
 .annotate 'line', 27
-  # rx rxquantr65 ** 0..*
-    set_addr $I66, rxquantr65_done
-    rx59_cur."!mark_push"(0, rx59_pos, $I66)
-  rxquantr65_loop:
+  # rx rxquantr64 ** 0..*
+    set_addr $I10, rxquantr64_done
+    rx58_cur."!mark_push"(0, rx58_pos, $I10)
+  rxquantr64_loop:
   # rx enumcharlist negate=0 
-    ge rx59_pos, rx59_eos, rx59_fail
-    sub $I10, rx59_pos, rx59_off
-    substr $S10, rx59_tgt, $I10, 1
+    ge rx58_pos, rx58_eos, rx58_fail
+    sub $I10, rx58_pos, rx58_off
+    substr $S10, rx58_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx59_fail
-    inc rx59_pos
-    (rx59_rep) = rx59_cur."!mark_commit"($I66)
-    rx59_cur."!mark_push"(rx59_rep, rx59_pos, $I66)
-    goto rxquantr65_loop
-  rxquantr65_done:
+    lt $I11, 0, rx58_fail
+    inc rx58_pos
+    set_addr $I10, rxquantr64_done
+    (rx58_rep) = rx58_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr64_done
+    rx58_cur."!mark_push"(rx58_rep, rx58_pos, $I10)
+    goto rxquantr64_loop
+  rxquantr64_done:
   # rxanchor eol
-    sub $I10, rx59_pos, rx59_off
-    is_cclass $I11, 4096, rx59_tgt, $I10
-    if $I11, rxanchor67_done
-    ne rx59_pos, rx59_eos, rx59_fail
-    eq rx59_pos, 0, rxanchor67_done
+    sub $I10, rx58_pos, rx58_off
+    is_cclass $I11, 4096, rx58_tgt, $I10
+    if $I11, rxanchor65_done
+    ne rx58_pos, rx58_eos, rx58_fail
+    eq rx58_pos, 0, rxanchor65_done
     dec $I10
-    is_cclass $I11, 4096, rx59_tgt, $I10
-    if $I11, rx59_fail
-  rxanchor67_done:
-  # rx subrule "ws" subtype=method negate=
-    rx59_cur."!cursor_pos"(rx59_pos)
-    $P10 = rx59_cur."ws"()
-    unless $P10, rx59_fail
-    rx59_pos = $P10."pos"()
+    is_cclass $I11, 4096, rx58_tgt, $I10
+    if $I11, rx58_fail
+  rxanchor65_done:
+  # rx subrule "ws" subtype=method negate=
+    rx58_cur."!cursor_pos"(rx58_pos)
+    $P10 = rx58_cur."ws"()
+    unless $P10, rx58_fail
+    rx58_pos = $P10."pos"()
   # rx subrule "MARKER" subtype=zerowidth negate=
-    rx59_cur."!cursor_pos"(rx59_pos)
-    $P10 = rx59_cur."MARKER"("endstmt")
-    unless $P10, rx59_fail
-    goto alt64_end
-  alt64_1:
+    rx58_cur."!cursor_pos"(rx58_pos)
+    $P10 = rx58_cur."MARKER"("endstmt")
+    unless $P10, rx58_fail
+    goto alt63_end
+  alt63_1:
 .annotate 'line', 28
-  # rx rxquantr68 ** 0..1
-    set_addr $I69, rxquantr68_done
-    rx59_cur."!mark_push"(0, rx59_pos, $I69)
-  rxquantr68_loop:
+  # rx rxquantr66 ** 0..1
+    set_addr $I10, rxquantr66_done
+    rx58_cur."!mark_push"(0, rx58_pos, $I10)
+  rxquantr66_loop:
   # rx subrule "unv" subtype=method negate=
-    rx59_cur."!cursor_pos"(rx59_pos)
-    $P10 = rx59_cur."unv"()
-    unless $P10, rx59_fail
-    rx59_pos = $P10."pos"()
-    (rx59_rep) = rx59_cur."!mark_commit"($I69)
-  rxquantr68_done:
+    rx58_cur."!cursor_pos"(rx58_pos)
+    $P10 = rx58_cur."unv"()
+    unless $P10, rx58_fail
+    goto rxsubrule67_pass
+  rxsubrule67_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx58_fail
+  rxsubrule67_pass:
+    set_addr $I10, rxsubrule67_back
+    rx58_cur."!mark_push"(0, rx58_pos, $I10, $P10)
+    rx58_pos = $P10."pos"()
+    set_addr $I10, rxquantr66_done
+    (rx58_rep) = rx58_cur."!mark_commit"($I10)
+  rxquantr66_done:
   # rxanchor eol
-    sub $I10, rx59_pos, rx59_off
-    is_cclass $I11, 4096, rx59_tgt, $I10
-    if $I11, rxanchor70_done
-    ne rx59_pos, rx59_eos, rx59_fail
-    eq rx59_pos, 0, rxanchor70_done
+    sub $I10, rx58_pos, rx58_off
+    is_cclass $I11, 4096, rx58_tgt, $I10
+    if $I11, rxanchor68_done
+    ne rx58_pos, rx58_eos, rx58_fail
+    eq rx58_pos, 0, rxanchor68_done
     dec $I10
-    is_cclass $I11, 4096, rx59_tgt, $I10
-    if $I11, rx59_fail
-  rxanchor70_done:
-  # rx subrule "ws" subtype=method negate=
-    rx59_cur."!cursor_pos"(rx59_pos)
-    $P10 = rx59_cur."ws"()
-    unless $P10, rx59_fail
-    rx59_pos = $P10."pos"()
+    is_cclass $I11, 4096, rx58_tgt, $I10
+    if $I11, rx58_fail
+  rxanchor68_done:
+  # rx subrule "ws" subtype=method negate=
+    rx58_cur."!cursor_pos"(rx58_pos)
+    $P10 = rx58_cur."ws"()
+    unless $P10, rx58_fail
+    rx58_pos = $P10."pos"()
   # rx subrule "MARKER" subtype=zerowidth negate=
-    rx59_cur."!cursor_pos"(rx59_pos)
-    $P10 = rx59_cur."MARKER"("endstmt")
-    unless $P10, rx59_fail
-  alt64_end:
+    rx58_cur."!cursor_pos"(rx58_pos)
+    $P10 = rx58_cur."MARKER"("endstmt")
+    unless $P10, rx58_fail
+  alt63_end:
 .annotate 'line', 29
-    (rx59_rep) = rx59_cur."!mark_commit"($I71)
-  rxquantr63_done:
+    set_addr $I10, rxquantr62_done
+    (rx58_rep) = rx58_cur."!mark_commit"($I10)
+  rxquantr62_done:
 .annotate 'line', 25
   # rx pass
-    rx59_cur."!cursor_pass"(rx59_pos, "ENDSTMT")
-    rx59_cur."!cursor_debug"("PASS  ", "ENDSTMT", " at pos=", rx59_pos)
-    .return (rx59_cur)
-  rx59_fail:
+    rx58_cur."!cursor_pass"(rx58_pos, "ENDSTMT")
+    rx58_cur."!cursor_debug"("PASS  ", "ENDSTMT", " at pos=", rx58_pos)
+    .return (rx58_cur)
+  rx58_restart:
 .annotate 'line', 4
-    (rx59_rep, rx59_pos, $I10, $P10) = rx59_cur."!mark_fail"(0)
-    lt rx59_pos, -1, rx59_done
-    eq rx59_pos, -1, rx59_fail
+    rx58_cur."!cursor_debug"("NEXT ", "ENDSTMT")
+  rx58_fail:
+    (rx58_rep, rx58_pos, $I10, $P10) = rx58_cur."!mark_fail"(0)
+    lt rx58_pos, -1, rx58_done
+    eq rx58_pos, -1, rx58_fail
     jump $I10
-  rx59_done:
-    rx59_cur."!cursor_fail"()
-    rx59_cur."!cursor_debug"("FAIL  ", "ENDSTMT")
-    .return (rx59_cur)
+  rx58_done:
+    rx58_cur."!cursor_fail"()
+    rx58_cur."!cursor_debug"("FAIL  ", "ENDSTMT")
+    .return (rx58_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__ENDSTMT"  :subid("20_1278500537.15927") :method
+.sub "!PREFIX__ENDSTMT"  :subid("20_1279529226.73787") :method
 .annotate 'line', 4
-    new $P61, "ResizablePMCArray"
-    push $P61, ""
-    .return ($P61)
+    new $P60, "ResizablePMCArray"
+    push $P60, ""
+    .return ($P60)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "ws"  :subid("21_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "ws"  :subid("21_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx73_tgt
-    .local int rx73_pos
-    .local int rx73_off
-    .local int rx73_eos
-    .local int rx73_rep
-    .local pmc rx73_cur
-    (rx73_cur, rx73_pos, rx73_tgt) = self."!cursor_start"()
-    rx73_cur."!cursor_debug"("START ", "ws")
-    .lex unicode:"$\x{a2}", rx73_cur
-    .local pmc match
-    .lex "$/", match
-    length rx73_eos, rx73_tgt
-    gt rx73_pos, rx73_eos, rx73_done
-    set rx73_off, 0
-    lt rx73_pos, 2, rx73_start
-    sub rx73_off, rx73_pos, 1
-    substr rx73_tgt, rx73_tgt, rx73_off
-  rx73_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan76_done
-    goto rxscan76_scan
-  rxscan76_loop:
-    ($P10) = rx73_cur."from"()
-    inc $P10
-    set rx73_pos, $P10
-    ge rx73_pos, rx73_eos, rxscan76_done
-  rxscan76_scan:
-    set_addr $I10, rxscan76_loop
-    rx73_cur."!mark_push"(0, rx73_pos, $I10)
-  rxscan76_done:
-  alt77_0:
+    .local string rx70_tgt
+    .local int rx70_pos
+    .local int rx70_off
+    .local int rx70_eos
+    .local int rx70_rep
+    .local pmc rx70_cur
+    (rx70_cur, rx70_pos, rx70_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx70_cur
+    .local pmc match
+    .lex "$/", match
+    length rx70_eos, rx70_tgt
+    gt rx70_pos, rx70_eos, rx70_done
+    set rx70_off, 0
+    lt rx70_pos, 2, rx70_start
+    sub rx70_off, rx70_pos, 1
+    substr rx70_tgt, rx70_tgt, rx70_off
+  rx70_start:
+    eq $I10, 1, rx70_restart
+    rx70_cur."!cursor_debug"("START ", "ws")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan73_done
+    goto rxscan73_scan
+  rxscan73_loop:
+    ($P10) = rx70_cur."from"()
+    inc $P10
+    set rx70_pos, $P10
+    ge rx70_pos, rx70_eos, rxscan73_done
+  rxscan73_scan:
+    set_addr $I10, rxscan73_loop
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
+  rxscan73_done:
+  alt74_0:
 .annotate 'line', 32
-    set_addr $I10, alt77_1
-    rx73_cur."!mark_push"(0, rx73_pos, $I10)
+    set_addr $I10, alt74_1
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
 .annotate 'line', 33
   # rx subrule "MARKED" subtype=zerowidth negate=
-    rx73_cur."!cursor_pos"(rx73_pos)
-    $P10 = rx73_cur."MARKED"("ws")
-    unless $P10, rx73_fail
-    goto alt77_end
-  alt77_1:
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."MARKED"("ws")
+    unless $P10, rx70_fail
+    goto alt74_end
+  alt74_1:
 .annotate 'line', 34
   # rx subrule "ww" subtype=zerowidth negate=1
-    rx73_cur."!cursor_pos"(rx73_pos)
-    $P10 = rx73_cur."ww"()
-    if $P10, rx73_fail
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."ww"()
+    if $P10, rx70_fail
 .annotate 'line', 39
-  # rx rxquantr78 ** 0..*
-    set_addr $I85, rxquantr78_done
-    rx73_cur."!mark_push"(0, rx73_pos, $I85)
-  rxquantr78_loop:
-  alt79_0:
+  # rx rxquantr75 ** 0..*
+    set_addr $I10, rxquantr75_done
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
+  rxquantr75_loop:
+  alt76_0:
 .annotate 'line', 35
-    set_addr $I10, alt79_1
-    rx73_cur."!mark_push"(0, rx73_pos, $I10)
-  # rx rxquantr80 ** 1..*
-    set_addr $I81, rxquantr80_done
-    rx73_cur."!mark_push"(0, -1, $I81)
-  rxquantr80_loop:
+    set_addr $I10, alt76_1
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
+  # rx rxquantr77 ** 1..*
+    set_addr $I10, rxquantr77_done
+    rx70_cur."!mark_push"(0, -1, $I10)
+  rxquantr77_loop:
   # rx enumcharlist negate=0 
-    ge rx73_pos, rx73_eos, rx73_fail
-    sub $I10, rx73_pos, rx73_off
-    substr $S10, rx73_tgt, $I10, 1
+    ge rx70_pos, rx70_eos, rx70_fail
+    sub $I10, rx70_pos, rx70_off
+    substr $S10, rx70_tgt, $I10, 1
     index $I11, unicode:"\n\x{b}\f\r\x{85}\u2028\u2029", $S10
-    lt $I11, 0, rx73_fail
-    inc rx73_pos
-    (rx73_rep) = rx73_cur."!mark_commit"($I81)
-    rx73_cur."!mark_push"(rx73_rep, rx73_pos, $I81)
-    goto rxquantr80_loop
-  rxquantr80_done:
-    goto alt79_end
-  alt79_1:
-    set_addr $I10, alt79_2
-    rx73_cur."!mark_push"(0, rx73_pos, $I10)
+    lt $I11, 0, rx70_fail
+    inc rx70_pos
+    set_addr $I10, rxquantr77_done
+    (rx70_rep) = rx70_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr77_done
+    rx70_cur."!mark_push"(rx70_rep, rx70_pos, $I10)
+    goto rxquantr77_loop
+  rxquantr77_done:
+    goto alt76_end
+  alt76_1:
+    set_addr $I10, alt76_2
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
 .annotate 'line', 36
   # rx literal  "#"
-    add $I11, rx73_pos, 1
-    gt $I11, rx73_eos, rx73_fail
-    sub $I11, rx73_pos, rx73_off
-    substr $S10, rx73_tgt, $I11, 1
-    ne $S10, "#", rx73_fail
-    add rx73_pos, 1
+    add $I11, rx70_pos, 1
+    gt $I11, rx70_eos, rx70_fail
+    sub $I11, rx70_pos, rx70_off
+    substr $S10, rx70_tgt, $I11, 1
+    ne $S10, "#", rx70_fail
+    add rx70_pos, 1
   # rx charclass_q N r 0..-1
-    sub $I10, rx73_pos, rx73_off
-    find_cclass $I11, 4096, rx73_tgt, $I10, rx73_eos
-    add rx73_pos, rx73_off, $I11
-    goto alt79_end
-  alt79_2:
-    set_addr $I10, alt79_3
-    rx73_cur."!mark_push"(0, rx73_pos, $I10)
+    sub $I10, rx70_pos, rx70_off
+    find_cclass $I11, 4096, rx70_tgt, $I10, rx70_eos
+    add rx70_pos, rx70_off, $I11
+    goto alt76_end
+  alt76_2:
+    set_addr $I10, alt76_3
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
 .annotate 'line', 37
   # rxanchor bol
-    eq rx73_pos, 0, rxanchor82_done
-    ge rx73_pos, rx73_eos, rx73_fail
-    sub $I10, rx73_pos, rx73_off
+    eq rx70_pos, 0, rxanchor78_done
+    ge rx70_pos, rx70_eos, rx70_fail
+    sub $I10, rx70_pos, rx70_off
     dec $I10
-    is_cclass $I11, 4096, rx73_tgt, $I10
-    unless $I11, rx73_fail
-  rxanchor82_done:
+    is_cclass $I11, 4096, rx70_tgt, $I10
+    unless $I11, rx70_fail
+  rxanchor78_done:
   # rx subrule "pod_comment" subtype=method negate=
-    rx73_cur."!cursor_pos"(rx73_pos)
-    $P10 = rx73_cur."pod_comment"()
-    unless $P10, rx73_fail
-    rx73_pos = $P10."pos"()
-    goto alt79_end
-  alt79_3:
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."pod_comment"()
+    unless $P10, rx70_fail
+    rx70_pos = $P10."pos"()
+    goto alt76_end
+  alt76_3:
 .annotate 'line', 38
-  # rx rxquantr83 ** 1..*
-    set_addr $I84, rxquantr83_done
-    rx73_cur."!mark_push"(0, -1, $I84)
-  rxquantr83_loop:
+  # rx rxquantr79 ** 1..*
+    set_addr $I10, rxquantr79_done
+    rx70_cur."!mark_push"(0, -1, $I10)
+  rxquantr79_loop:
   # rx enumcharlist negate=0 
-    ge rx73_pos, rx73_eos, rx73_fail
-    sub $I10, rx73_pos, rx73_off
-    substr $S10, rx73_tgt, $I10, 1
+    ge rx70_pos, rx70_eos, rx70_fail
+    sub $I10, rx70_pos, rx70_off
+    substr $S10, rx70_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx73_fail
-    inc rx73_pos
-    (rx73_rep) = rx73_cur."!mark_commit"($I84)
-    rx73_cur."!mark_push"(rx73_rep, rx73_pos, $I84)
-    goto rxquantr83_loop
-  rxquantr83_done:
-  alt79_end:
+    lt $I11, 0, rx70_fail
+    inc rx70_pos
+    set_addr $I10, rxquantr79_done
+    (rx70_rep) = rx70_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr79_done
+    rx70_cur."!mark_push"(rx70_rep, rx70_pos, $I10)
+    goto rxquantr79_loop
+  rxquantr79_done:
+  alt76_end:
 .annotate 'line', 39
-    (rx73_rep) = rx73_cur."!mark_commit"($I85)
-    rx73_cur."!mark_push"(rx73_rep, rx73_pos, $I85)
-    goto rxquantr78_loop
-  rxquantr78_done:
+    set_addr $I10, rxquantr75_done
+    (rx70_rep) = rx70_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr75_done
+    rx70_cur."!mark_push"(rx70_rep, rx70_pos, $I10)
+    goto rxquantr75_loop
+  rxquantr75_done:
 .annotate 'line', 40
   # rx subrule "MARKER" subtype=zerowidth negate=
-    rx73_cur."!cursor_pos"(rx73_pos)
-    $P10 = rx73_cur."MARKER"("ws")
-    unless $P10, rx73_fail
-  alt77_end:
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."MARKER"("ws")
+    unless $P10, rx70_fail
+  alt74_end:
 .annotate 'line', 32
   # rx pass
-    rx73_cur."!cursor_pass"(rx73_pos, "ws")
-    rx73_cur."!cursor_debug"("PASS  ", "ws", " at pos=", rx73_pos)
-    .return (rx73_cur)
-  rx73_fail:
+    rx70_cur."!cursor_pass"(rx70_pos, "ws")
+    rx70_cur."!cursor_debug"("PASS  ", "ws", " at pos=", rx70_pos)
+    .return (rx70_cur)
+  rx70_restart:
 .annotate 'line', 4
-    (rx73_rep, rx73_pos, $I10, $P10) = rx73_cur."!mark_fail"(0)
-    lt rx73_pos, -1, rx73_done
-    eq rx73_pos, -1, rx73_fail
+    rx70_cur."!cursor_debug"("NEXT ", "ws")
+  rx70_fail:
+    (rx70_rep, rx70_pos, $I10, $P10) = rx70_cur."!mark_fail"(0)
+    lt rx70_pos, -1, rx70_done
+    eq rx70_pos, -1, rx70_fail
     jump $I10
-  rx73_done:
-    rx73_cur."!cursor_fail"()
-    rx73_cur."!cursor_debug"("FAIL  ", "ws")
-    .return (rx73_cur)
+  rx70_done:
+    rx70_cur."!cursor_fail"()
+    rx70_cur."!cursor_debug"("FAIL  ", "ws")
+    .return (rx70_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__ws"  :subid("22_1278500537.15927") :method
+.sub "!PREFIX__ws"  :subid("22_1279529226.73787") :method
 .annotate 'line', 4
-    new $P75, "ResizablePMCArray"
-    push $P75, ""
-    push $P75, ""
-    .return ($P75)
+    new $P72, "ResizablePMCArray"
+    push $P72, ""
+    push $P72, ""
+    .return ($P72)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "unv"  :subid("23_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "unv"  :subid("23_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .const 'Sub' $P94 = "25_1278500537.15927" 
-    capture_lex $P94
-    .local string rx87_tgt
-    .local int rx87_pos
-    .local int rx87_off
-    .local int rx87_eos
-    .local int rx87_rep
-    .local pmc rx87_cur
-    (rx87_cur, rx87_pos, rx87_tgt) = self."!cursor_start"()
-    rx87_cur."!cursor_debug"("START ", "unv")
-    .lex unicode:"$\x{a2}", rx87_cur
+    .const 'Sub' $P88 = "25_1279529226.73787" 
+    capture_lex $P88
+    .local string rx81_tgt
+    .local int rx81_pos
+    .local int rx81_off
+    .local int rx81_eos
+    .local int rx81_rep
+    .local pmc rx81_cur
+    (rx81_cur, rx81_pos, rx81_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx81_cur
     .local pmc match
     .lex "$/", match
-    length rx87_eos, rx87_tgt
-    gt rx87_pos, rx87_eos, rx87_done
-    set rx87_off, 0
-    lt rx87_pos, 2, rx87_start
-    sub rx87_off, rx87_pos, 1
-    substr rx87_tgt, rx87_tgt, rx87_off
-  rx87_start:
+    length rx81_eos, rx81_tgt
+    gt rx81_pos, rx81_eos, rx81_done
+    set rx81_off, 0
+    lt rx81_pos, 2, rx81_start
+    sub rx81_off, rx81_pos, 1
+    substr rx81_tgt, rx81_tgt, rx81_off
+  rx81_start:
+    eq $I10, 1, rx81_restart
+    rx81_cur."!cursor_debug"("START ", "unv")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan90_done
-    goto rxscan90_scan
-  rxscan90_loop:
-    ($P10) = rx87_cur."from"()
+    ne $I10, -1, rxscan84_done
+    goto rxscan84_scan
+  rxscan84_loop:
+    ($P10) = rx81_cur."from"()
     inc $P10
-    set rx87_pos, $P10
-    ge rx87_pos, rx87_eos, rxscan90_done
-  rxscan90_scan:
-    set_addr $I10, rxscan90_loop
-    rx87_cur."!mark_push"(0, rx87_pos, $I10)
-  rxscan90_done:
-  alt91_0:
+    set rx81_pos, $P10
+    ge rx81_pos, rx81_eos, rxscan84_done
+  rxscan84_scan:
+    set_addr $I10, rxscan84_loop
+    rx81_cur."!mark_push"(0, rx81_pos, $I10)
+  rxscan84_done:
+  alt85_0:
 .annotate 'line', 45
-    set_addr $I10, alt91_1
-    rx87_cur."!mark_push"(0, rx87_pos, $I10)
+    set_addr $I10, alt85_1
+    rx81_cur."!mark_push"(0, rx81_pos, $I10)
 .annotate 'line', 46
   # rxanchor bol
-    eq rx87_pos, 0, rxanchor92_done
-    ge rx87_pos, rx87_eos, rx87_fail
-    sub $I10, rx87_pos, rx87_off
+    eq rx81_pos, 0, rxanchor86_done
+    ge rx81_pos, rx81_eos, rx81_fail
+    sub $I10, rx81_pos, rx81_off
     dec $I10
-    is_cclass $I11, 4096, rx87_tgt, $I10
-    unless $I11, rx87_fail
-  rxanchor92_done:
+    is_cclass $I11, 4096, rx81_tgt, $I10
+    unless $I11, rx81_fail
+  rxanchor86_done:
   # rx subrule "before" subtype=zerowidth negate=
-    rx87_cur."!cursor_pos"(rx87_pos)
-    .const 'Sub' $P94 = "25_1278500537.15927" 
-    capture_lex $P94
-    $P10 = rx87_cur."before"($P94)
-    unless $P10, rx87_fail
+    rx81_cur."!cursor_pos"(rx81_pos)
+    .const 'Sub' $P88 = "25_1279529226.73787" 
+    capture_lex $P88
+    $P10 = rx81_cur."before"($P88)
+    unless $P10, rx81_fail
   # rx subrule "pod_comment" subtype=method negate=
-    rx87_cur."!cursor_pos"(rx87_pos)
-    $P10 = rx87_cur."pod_comment"()
-    unless $P10, rx87_fail
-    rx87_pos = $P10."pos"()
-    goto alt91_end
-  alt91_1:
-    set_addr $I10, alt91_2
-    rx87_cur."!mark_push"(0, rx87_pos, $I10)
+    rx81_cur."!cursor_pos"(rx81_pos)
+    $P10 = rx81_cur."pod_comment"()
+    unless $P10, rx81_fail
+    rx81_pos = $P10."pos"()
+    goto alt85_end
+  alt85_1:
+    set_addr $I10, alt85_2
+    rx81_cur."!mark_push"(0, rx81_pos, $I10)
 .annotate 'line', 47
-  # rx rxquantr100 ** 0..*
-    set_addr $I101, rxquantr100_done
-    rx87_cur."!mark_push"(0, rx87_pos, $I101)
-  rxquantr100_loop:
+  # rx rxquantr93 ** 0..*
+    set_addr $I10, rxquantr93_done
+    rx81_cur."!mark_push"(0, rx81_pos, $I10)
+  rxquantr93_loop:
   # rx enumcharlist negate=0 
-    ge rx87_pos, rx87_eos, rx87_fail
-    sub $I10, rx87_pos, rx87_off
-    substr $S10, rx87_tgt, $I10, 1
+    ge rx81_pos, rx81_eos, rx81_fail
+    sub $I10, rx81_pos, rx81_off
+    substr $S10, rx81_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx87_fail
-    inc rx87_pos
-    (rx87_rep) = rx87_cur."!mark_commit"($I101)
-    rx87_cur."!mark_push"(rx87_rep, rx87_pos, $I101)
-    goto rxquantr100_loop
-  rxquantr100_done:
+    lt $I11, 0, rx81_fail
+    inc rx81_pos
+    set_addr $I10, rxquantr93_done
+    (rx81_rep) = rx81_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr93_done
+    rx81_cur."!mark_push"(rx81_rep, rx81_pos, $I10)
+    goto rxquantr93_loop
+  rxquantr93_done:
   # rx literal  "#"
-    add $I11, rx87_pos, 1
-    gt $I11, rx87_eos, rx87_fail
-    sub $I11, rx87_pos, rx87_off
-    substr $S10, rx87_tgt, $I11, 1
-    ne $S10, "#", rx87_fail
-    add rx87_pos, 1
+    add $I11, rx81_pos, 1
+    gt $I11, rx81_eos, rx81_fail
+    sub $I11, rx81_pos, rx81_off
+    substr $S10, rx81_tgt, $I11, 1
+    ne $S10, "#", rx81_fail
+    add rx81_pos, 1
   # rx charclass_q N r 0..-1
-    sub $I10, rx87_pos, rx87_off
-    find_cclass $I11, 4096, rx87_tgt, $I10, rx87_eos
-    add rx87_pos, rx87_off, $I11
-    goto alt91_end
-  alt91_2:
+    sub $I10, rx81_pos, rx81_off
+    find_cclass $I11, 4096, rx81_tgt, $I10, rx81_eos
+    add rx81_pos, rx81_off, $I11
+    goto alt85_end
+  alt85_2:
 .annotate 'line', 48
-  # rx rxquantr102 ** 1..*
-    set_addr $I103, rxquantr102_done
-    rx87_cur."!mark_push"(0, -1, $I103)
-  rxquantr102_loop:
+  # rx rxquantr94 ** 1..*
+    set_addr $I10, rxquantr94_done
+    rx81_cur."!mark_push"(0, -1, $I10)
+  rxquantr94_loop:
   # rx enumcharlist negate=0 
-    ge rx87_pos, rx87_eos, rx87_fail
-    sub $I10, rx87_pos, rx87_off
-    substr $S10, rx87_tgt, $I10, 1
+    ge rx81_pos, rx81_eos, rx81_fail
+    sub $I10, rx81_pos, rx81_off
+    substr $S10, rx81_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx87_fail
-    inc rx87_pos
-    (rx87_rep) = rx87_cur."!mark_commit"($I103)
-    rx87_cur."!mark_push"(rx87_rep, rx87_pos, $I103)
-    goto rxquantr102_loop
-  rxquantr102_done:
-  alt91_end:
+    lt $I11, 0, rx81_fail
+    inc rx81_pos
+    set_addr $I10, rxquantr94_done
+    (rx81_rep) = rx81_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr94_done
+    rx81_cur."!mark_push"(rx81_rep, rx81_pos, $I10)
+    goto rxquantr94_loop
+  rxquantr94_done:
+  alt85_end:
 .annotate 'line', 43
   # rx pass
-    rx87_cur."!cursor_pass"(rx87_pos, "unv")
-    rx87_cur."!cursor_debug"("PASS  ", "unv", " at pos=", rx87_pos)
-    .return (rx87_cur)
-  rx87_fail:
+    rx81_cur."!cursor_pass"(rx81_pos, "unv")
+    rx81_cur."!cursor_debug"("PASS  ", "unv", " at pos=", rx81_pos)
+    .return (rx81_cur)
+  rx81_restart:
 .annotate 'line', 4
-    (rx87_rep, rx87_pos, $I10, $P10) = rx87_cur."!mark_fail"(0)
-    lt rx87_pos, -1, rx87_done
-    eq rx87_pos, -1, rx87_fail
+    rx81_cur."!cursor_debug"("NEXT ", "unv")
+  rx81_fail:
+    (rx81_rep, rx81_pos, $I10, $P10) = rx81_cur."!mark_fail"(0)
+    lt rx81_pos, -1, rx81_done
+    eq rx81_pos, -1, rx81_fail
     jump $I10
-  rx87_done:
-    rx87_cur."!cursor_fail"()
-    rx87_cur."!cursor_debug"("FAIL  ", "unv")
-    .return (rx87_cur)
+  rx81_done:
+    rx81_cur."!cursor_fail"()
+    rx81_cur."!cursor_debug"("FAIL  ", "unv")
+    .return (rx81_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__unv"  :subid("24_1278500537.15927") :method
+.sub "!PREFIX__unv"  :subid("24_1279529226.73787") :method
 .annotate 'line', 4
-    new $P89, "ResizablePMCArray"
-    push $P89, ""
-    push $P89, ""
-    push $P89, ""
-    .return ($P89)
+    new $P83, "ResizablePMCArray"
+    push $P83, ""
+    push $P83, ""
+    push $P83, ""
+    .return ($P83)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block93"  :anon :subid("25_1278500537.15927") :method :outer("23_1278500537.15927")
+.sub "_block87"  :anon :subid("25_1279529226.73787") :method :outer("23_1279529226.73787")
 .annotate 'line', 46
-    .local string rx95_tgt
-    .local int rx95_pos
-    .local int rx95_off
-    .local int rx95_eos
-    .local int rx95_rep
-    .local pmc rx95_cur
-    (rx95_cur, rx95_pos, rx95_tgt) = self."!cursor_start"()
-    rx95_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx95_cur
-    .local pmc match
-    .lex "$/", match
-    length rx95_eos, rx95_tgt
-    gt rx95_pos, rx95_eos, rx95_done
-    set rx95_off, 0
-    lt rx95_pos, 2, rx95_start
-    sub rx95_off, rx95_pos, 1
-    substr rx95_tgt, rx95_tgt, rx95_off
-  rx95_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan96_done
-    goto rxscan96_scan
-  rxscan96_loop:
-    ($P10) = rx95_cur."from"()
-    inc $P10
-    set rx95_pos, $P10
-    ge rx95_pos, rx95_eos, rxscan96_done
-  rxscan96_scan:
-    set_addr $I10, rxscan96_loop
-    rx95_cur."!mark_push"(0, rx95_pos, $I10)
-  rxscan96_done:
-  # rx rxquantr97 ** 0..*
-    set_addr $I98, rxquantr97_done
-    rx95_cur."!mark_push"(0, rx95_pos, $I98)
-  rxquantr97_loop:
+    .local string rx89_tgt
+    .local int rx89_pos
+    .local int rx89_off
+    .local int rx89_eos
+    .local int rx89_rep
+    .local pmc rx89_cur
+    (rx89_cur, rx89_pos, rx89_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx89_cur
+    .local pmc match
+    .lex "$/", match
+    length rx89_eos, rx89_tgt
+    gt rx89_pos, rx89_eos, rx89_done
+    set rx89_off, 0
+    lt rx89_pos, 2, rx89_start
+    sub rx89_off, rx89_pos, 1
+    substr rx89_tgt, rx89_tgt, rx89_off
+  rx89_start:
+    eq $I10, 1, rx89_restart
+    rx89_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan90_done
+    goto rxscan90_scan
+  rxscan90_loop:
+    ($P10) = rx89_cur."from"()
+    inc $P10
+    set rx89_pos, $P10
+    ge rx89_pos, rx89_eos, rxscan90_done
+  rxscan90_scan:
+    set_addr $I10, rxscan90_loop
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
+  rxscan90_done:
+  # rx rxquantr91 ** 0..*
+    set_addr $I10, rxquantr91_done
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
+  rxquantr91_loop:
   # rx enumcharlist negate=0 
-    ge rx95_pos, rx95_eos, rx95_fail
-    sub $I10, rx95_pos, rx95_off
-    substr $S10, rx95_tgt, $I10, 1
+    ge rx89_pos, rx89_eos, rx89_fail
+    sub $I10, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx95_fail
-    inc rx95_pos
-    (rx95_rep) = rx95_cur."!mark_commit"($I98)
-    rx95_cur."!mark_push"(rx95_rep, rx95_pos, $I98)
-    goto rxquantr97_loop
-  rxquantr97_done:
+    lt $I11, 0, rx89_fail
+    inc rx89_pos
+    set_addr $I10, rxquantr91_done
+    (rx89_rep) = rx89_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr91_done
+    rx89_cur."!mark_push"(rx89_rep, rx89_pos, $I10)
+    goto rxquantr91_loop
+  rxquantr91_done:
   # rx literal  "="
-    add $I11, rx95_pos, 1
-    gt $I11, rx95_eos, rx95_fail
-    sub $I11, rx95_pos, rx95_off
-    substr $S10, rx95_tgt, $I11, 1
-    ne $S10, "=", rx95_fail
-    add rx95_pos, 1
-  alt99_0:
-    set_addr $I10, alt99_1
-    rx95_cur."!mark_push"(0, rx95_pos, $I10)
+    add $I11, rx89_pos, 1
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 1
+    ne $S10, "=", rx89_fail
+    add rx89_pos, 1
+  alt92_0:
+    set_addr $I10, alt92_1
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
   # rx charclass w
-    ge rx95_pos, rx95_eos, rx95_fail
-    sub $I10, rx95_pos, rx95_off
-    is_cclass $I11, 8192, rx95_tgt, $I10
-    unless $I11, rx95_fail
-    inc rx95_pos
-    goto alt99_end
-  alt99_1:
+    ge rx89_pos, rx89_eos, rx89_fail
+    sub $I10, rx89_pos, rx89_off
+    is_cclass $I11, 8192, rx89_tgt, $I10
+    unless $I11, rx89_fail
+    inc rx89_pos
+    goto alt92_end
+  alt92_1:
   # rx literal  "\\"
-    add $I11, rx95_pos, 1
-    gt $I11, rx95_eos, rx95_fail
-    sub $I11, rx95_pos, rx95_off
-    substr $S10, rx95_tgt, $I11, 1
-    ne $S10, "\\", rx95_fail
-    add rx95_pos, 1
-  alt99_end:
-  # rx pass
-    rx95_cur."!cursor_pass"(rx95_pos, "")
-    rx95_cur."!cursor_debug"("PASS  ", "", " at pos=", rx95_pos)
-    .return (rx95_cur)
-  rx95_fail:
-    (rx95_rep, rx95_pos, $I10, $P10) = rx95_cur."!mark_fail"(0)
-    lt rx95_pos, -1, rx95_done
-    eq rx95_pos, -1, rx95_fail
-    jump $I10
-  rx95_done:
-    rx95_cur."!cursor_fail"()
-    rx95_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx95_cur)
+    add $I11, rx89_pos, 1
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 1
+    ne $S10, "\\", rx89_fail
+    add rx89_pos, 1
+  alt92_end:
+  # rx pass
+    rx89_cur."!cursor_pass"(rx89_pos, "")
+    rx89_cur."!cursor_debug"("PASS  ", "", " at pos=", rx89_pos)
+    .return (rx89_cur)
+  rx89_restart:
+    rx89_cur."!cursor_debug"("NEXT ", "")
+  rx89_fail:
+    (rx89_rep, rx89_pos, $I10, $P10) = rx89_cur."!mark_fail"(0)
+    lt rx89_pos, -1, rx89_done
+    eq rx89_pos, -1, rx89_fail
+    jump $I10
+  rx89_done:
+    rx89_cur."!cursor_fail"()
+    rx89_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx89_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "pod_comment"  :subid("26_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .const 'Sub' $P145 = "28_1278500537.15927" 
-    capture_lex $P145
-    .local string rx105_tgt
-    .local int rx105_pos
-    .local int rx105_off
-    .local int rx105_eos
-    .local int rx105_rep
-    .local pmc rx105_cur
-    (rx105_cur, rx105_pos, rx105_tgt) = self."!cursor_start"()
-    rx105_cur."!cursor_debug"("START ", "pod_comment")
-    .lex unicode:"$\x{a2}", rx105_cur
-    .local pmc match
-    .lex "$/", match
-    length rx105_eos, rx105_tgt
-    gt rx105_pos, rx105_eos, rx105_done
-    set rx105_off, 0
-    lt rx105_pos, 2, rx105_start
-    sub rx105_off, rx105_pos, 1
-    substr rx105_tgt, rx105_tgt, rx105_off
-  rx105_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan108_done
-    goto rxscan108_scan
-  rxscan108_loop:
-    ($P10) = rx105_cur."from"()
-    inc $P10
-    set rx105_pos, $P10
-    ge rx105_pos, rx105_eos, rxscan108_done
-  rxscan108_scan:
-    set_addr $I10, rxscan108_loop
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
-  rxscan108_done:
+.sub "pod_comment"  :subid("26_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .const 'Sub' $P127 = "28_1279529226.73787" 
+    capture_lex $P127
+    .local string rx96_tgt
+    .local int rx96_pos
+    .local int rx96_off
+    .local int rx96_eos
+    .local int rx96_rep
+    .local pmc rx96_cur
+    (rx96_cur, rx96_pos, rx96_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx96_cur
+    .local pmc match
+    .lex "$/", match
+    length rx96_eos, rx96_tgt
+    gt rx96_pos, rx96_eos, rx96_done
+    set rx96_off, 0
+    lt rx96_pos, 2, rx96_start
+    sub rx96_off, rx96_pos, 1
+    substr rx96_tgt, rx96_tgt, rx96_off
+  rx96_start:
+    eq $I10, 1, rx96_restart
+    rx96_cur."!cursor_debug"("START ", "pod_comment")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan99_done
+    goto rxscan99_scan
+  rxscan99_loop:
+    ($P10) = rx96_cur."from"()
+    inc $P10
+    set rx96_pos, $P10
+    ge rx96_pos, rx96_eos, rxscan99_done
+  rxscan99_scan:
+    set_addr $I10, rxscan99_loop
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  rxscan99_done:
 .annotate 'line', 53
   # rxanchor bol
-    eq rx105_pos, 0, rxanchor109_done
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
+    eq rx96_pos, 0, rxanchor100_done
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
     dec $I10
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    unless $I11, rx105_fail
-  rxanchor109_done:
-  # rx rxquantr110 ** 0..*
-    set_addr $I111, rxquantr110_done
-    rx105_cur."!mark_push"(0, rx105_pos, $I111)
-  rxquantr110_loop:
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    unless $I11, rx96_fail
+  rxanchor100_done:
+  # rx rxquantr101 ** 0..*
+    set_addr $I10, rxquantr101_done
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  rxquantr101_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I111)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I111)
-    goto rxquantr110_loop
-  rxquantr110_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr101_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr101_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr101_loop
+  rxquantr101_done:
   # rx literal  "="
-    add $I11, rx105_pos, 1
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 1
-    ne $S10, "=", rx105_fail
-    add rx105_pos, 1
-  alt112_0:
+    add $I11, rx96_pos, 1
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 1
+    ne $S10, "=", rx96_fail
+    add rx96_pos, 1
+  alt102_0:
 .annotate 'line', 54
-    set_addr $I10, alt112_1
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    set_addr $I10, alt102_1
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
 .annotate 'line', 55
   # rx literal  "begin"
-    add $I11, rx105_pos, 5
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 5
-    ne $S10, "begin", rx105_fail
-    add rx105_pos, 5
-  # rx rxquantr113 ** 1..*
-    set_addr $I114, rxquantr113_done
-    rx105_cur."!mark_push"(0, -1, $I114)
-  rxquantr113_loop:
+    add $I11, rx96_pos, 5
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 5
+    ne $S10, "begin", rx96_fail
+    add rx96_pos, 5
+  # rx rxquantr103 ** 1..*
+    set_addr $I10, rxquantr103_done
+    rx96_cur."!mark_push"(0, -1, $I10)
+  rxquantr103_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I114)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I114)
-    goto rxquantr113_loop
-  rxquantr113_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr103_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr103_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr103_loop
+  rxquantr103_done:
   # rx literal  "END"
-    add $I11, rx105_pos, 3
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 3
-    ne $S10, "END", rx105_fail
-    add rx105_pos, 3
+    add $I11, rx96_pos, 3
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 3
+    ne $S10, "END", rx96_fail
+    add rx96_pos, 3
   # rxanchor rwb
-    le rx105_pos, 0, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    if $I11, rx105_fail
+    le rx96_pos, 0, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    if $I11, rx96_fail
     dec $I10
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    unless $I11, rx105_fail
-  alt115_0:
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    unless $I11, rx96_fail
+  alt104_0:
 .annotate 'line', 56
-    set_addr $I10, alt115_1
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
-  # rx rxquantf116 ** 0..*
-    set_addr $I10, rxquantf116_loop
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
-    goto rxquantf116_done
-  rxquantf116_loop:
+    set_addr $I10, alt104_1
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  # rx rxquantf105 ** 0..*
+    set_addr $I10, rxquantf105_loop
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+    goto rxquantf105_done
+  rxquantf105_loop:
   # rx charclass .
-    ge rx105_pos, rx105_eos, rx105_fail
-    inc rx105_pos
-    set_addr $I10, rxquantf116_loop
-    rx105_cur."!mark_push"($I117, rx105_pos, $I10)
-  rxquantf116_done:
+    ge rx96_pos, rx96_eos, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantf105_loop
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+  rxquantf105_done:
   # rx charclass nl
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    unless $I11, rx105_fail
-    substr $S10, rx105_tgt, $I10, 2
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    unless $I11, rx96_fail
+    substr $S10, rx96_tgt, $I10, 2
     iseq $I11, $S10, "\r\n"
-    add rx105_pos, $I11
-    inc rx105_pos
-  # rx rxquantr118 ** 0..*
-    set_addr $I119, rxquantr118_done
-    rx105_cur."!mark_push"(0, rx105_pos, $I119)
-  rxquantr118_loop:
+    add rx96_pos, $I11
+    inc rx96_pos
+  # rx rxquantr107 ** 0..*
+    set_addr $I10, rxquantr107_done
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  rxquantr107_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I119)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I119)
-    goto rxquantr118_loop
-  rxquantr118_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr107_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr107_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr107_loop
+  rxquantr107_done:
   # rx literal  "=end"
-    add $I11, rx105_pos, 4
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 4
-    ne $S10, "=end", rx105_fail
-    add rx105_pos, 4
-  # rx rxquantr120 ** 1..*
-    set_addr $I121, rxquantr120_done
-    rx105_cur."!mark_push"(0, -1, $I121)
-  rxquantr120_loop:
+    add $I11, rx96_pos, 4
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 4
+    ne $S10, "=end", rx96_fail
+    add rx96_pos, 4
+  # rx rxquantr108 ** 1..*
+    set_addr $I10, rxquantr108_done
+    rx96_cur."!mark_push"(0, -1, $I10)
+  rxquantr108_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I121)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I121)
-    goto rxquantr120_loop
-  rxquantr120_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr108_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr108_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr108_loop
+  rxquantr108_done:
   # rx literal  "END"
-    add $I11, rx105_pos, 3
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 3
-    ne $S10, "END", rx105_fail
-    add rx105_pos, 3
+    add $I11, rx96_pos, 3
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 3
+    ne $S10, "END", rx96_fail
+    add rx96_pos, 3
   # rxanchor rwb
-    le rx105_pos, 0, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    if $I11, rx105_fail
+    le rx96_pos, 0, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    if $I11, rx96_fail
     dec $I10
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    unless $I11, rx105_fail
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    unless $I11, rx96_fail
   # rx charclass_q N r 0..-1
-    sub $I10, rx105_pos, rx105_off
-    find_cclass $I11, 4096, rx105_tgt, $I10, rx105_eos
-    add rx105_pos, rx105_off, $I11
-    goto alt115_end
-  alt115_1:
+    sub $I10, rx96_pos, rx96_off
+    find_cclass $I11, 4096, rx96_tgt, $I10, rx96_eos
+    add rx96_pos, rx96_off, $I11
+    goto alt104_end
+  alt104_1:
   # rx charclass_q . r 0..-1
-    sub $I10, rx105_pos, rx105_off
-    find_not_cclass $I11, 65535, rx105_tgt, $I10, rx105_eos
-    add rx105_pos, rx105_off, $I11
-  alt115_end:
+    sub $I10, rx96_pos, rx96_off
+    find_not_cclass $I11, 65535, rx96_tgt, $I10, rx96_eos
+    add rx96_pos, rx96_off, $I11
+  alt104_end:
 .annotate 'line', 55
-    goto alt112_end
-  alt112_1:
-    set_addr $I10, alt112_2
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    goto alt102_end
+  alt102_1:
+    set_addr $I10, alt102_2
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
 .annotate 'line', 57
   # rx literal  "begin"
-    add $I11, rx105_pos, 5
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 5
-    ne $S10, "begin", rx105_fail
-    add rx105_pos, 5
-  # rx rxquantr122 ** 1..*
-    set_addr $I123, rxquantr122_done
-    rx105_cur."!mark_push"(0, -1, $I123)
-  rxquantr122_loop:
+    add $I11, rx96_pos, 5
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 5
+    ne $S10, "begin", rx96_fail
+    add rx96_pos, 5
+  # rx rxquantr109 ** 1..*
+    set_addr $I10, rxquantr109_done
+    rx96_cur."!mark_push"(0, -1, $I10)
+  rxquantr109_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I123)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I123)
-    goto rxquantr122_loop
-  rxquantr122_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr109_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr109_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr109_loop
+  rxquantr109_done:
   # rx subrule "identifier" subtype=capture negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."identifier"()
-    unless $P10, rx105_fail
-    rx105_cur."!mark_push"(0, -1, 0, $P10)
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."identifier"()
+    unless $P10, rx96_fail
+    rx96_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("identifier")
-    rx105_pos = $P10."pos"()
-  alt124_0:
+    rx96_pos = $P10."pos"()
+  alt110_0:
 .annotate 'line', 58
-    set_addr $I10, alt124_1
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    set_addr $I10, alt110_1
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
 .annotate 'line', 59
-  # rx rxquantf125 ** 0..*
-    set_addr $I10, rxquantf125_loop
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
-    goto rxquantf125_done
-  rxquantf125_loop:
+  # rx rxquantf111 ** 0..*
+    set_addr $I10, rxquantf111_loop
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+    goto rxquantf111_done
+  rxquantf111_loop:
   # rx charclass .
-    ge rx105_pos, rx105_eos, rx105_fail
-    inc rx105_pos
-    set_addr $I10, rxquantf125_loop
-    rx105_cur."!mark_push"($I126, rx105_pos, $I10)
-  rxquantf125_done:
+    ge rx96_pos, rx96_eos, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantf111_loop
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+  rxquantf111_done:
   # rx charclass nl
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    unless $I11, rx105_fail
-    substr $S10, rx105_tgt, $I10, 2
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    unless $I11, rx96_fail
+    substr $S10, rx96_tgt, $I10, 2
     iseq $I11, $S10, "\r\n"
-    add rx105_pos, $I11
-    inc rx105_pos
-  # rx rxquantr127 ** 0..*
-    set_addr $I128, rxquantr127_done
-    rx105_cur."!mark_push"(0, rx105_pos, $I128)
-  rxquantr127_loop:
+    add rx96_pos, $I11
+    inc rx96_pos
+  # rx rxquantr113 ** 0..*
+    set_addr $I10, rxquantr113_done
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  rxquantr113_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I128)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I128)
-    goto rxquantr127_loop
-  rxquantr127_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr113_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr113_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr113_loop
+  rxquantr113_done:
   # rx literal  "=end"
-    add $I11, rx105_pos, 4
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 4
-    ne $S10, "=end", rx105_fail
-    add rx105_pos, 4
-  # rx rxquantr129 ** 1..*
-    set_addr $I130, rxquantr129_done
-    rx105_cur."!mark_push"(0, -1, $I130)
-  rxquantr129_loop:
+    add $I11, rx96_pos, 4
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 4
+    ne $S10, "=end", rx96_fail
+    add rx96_pos, 4
+  # rx rxquantr114 ** 1..*
+    set_addr $I10, rxquantr114_done
+    rx96_cur."!mark_push"(0, -1, $I10)
+  rxquantr114_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I130)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I130)
-    goto rxquantr129_loop
-  rxquantr129_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr114_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr114_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr114_loop
+  rxquantr114_done:
   # rx subrule "!BACKREF" subtype=method negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."!BACKREF"("identifier")
-    unless $P10, rx105_fail
-    rx105_pos = $P10."pos"()
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."!BACKREF"("identifier")
+    unless $P10, rx96_fail
+    rx96_pos = $P10."pos"()
   # rxanchor rwb
-    le rx105_pos, 0, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    if $I11, rx105_fail
+    le rx96_pos, 0, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    if $I11, rx96_fail
     dec $I10
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    unless $I11, rx105_fail
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    unless $I11, rx96_fail
   # rx charclass_q N r 0..-1
-    sub $I10, rx105_pos, rx105_off
-    find_cclass $I11, 4096, rx105_tgt, $I10, rx105_eos
-    add rx105_pos, rx105_off, $I11
-    goto alt124_end
-  alt124_1:
+    sub $I10, rx96_pos, rx96_off
+    find_cclass $I11, 4096, rx96_tgt, $I10, rx96_eos
+    add rx96_pos, rx96_off, $I11
+    goto alt110_end
+  alt110_1:
 .annotate 'line', 60
   # rx subrule "panic" subtype=method negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."panic"("=begin without matching =end")
-    unless $P10, rx105_fail
-    rx105_pos = $P10."pos"()
-  alt124_end:
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."panic"("=begin without matching =end")
+    unless $P10, rx96_fail
+    rx96_pos = $P10."pos"()
+  alt110_end:
 .annotate 'line', 57
-    goto alt112_end
-  alt112_2:
-    set_addr $I10, alt112_3
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    goto alt102_end
+  alt102_2:
+    set_addr $I10, alt102_3
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
 .annotate 'line', 62
   # rx literal  "begin"
-    add $I11, rx105_pos, 5
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 5
-    ne $S10, "begin", rx105_fail
-    add rx105_pos, 5
+    add $I11, rx96_pos, 5
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 5
+    ne $S10, "begin", rx96_fail
+    add rx96_pos, 5
   # rxanchor rwb
-    le rx105_pos, 0, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    if $I11, rx105_fail
+    le rx96_pos, 0, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    if $I11, rx96_fail
     dec $I10
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    unless $I11, rx105_fail
-  # rx rxquantr132 ** 0..*
-    set_addr $I133, rxquantr132_done
-    rx105_cur."!mark_push"(0, rx105_pos, $I133)
-  rxquantr132_loop:
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    unless $I11, rx96_fail
+  # rx rxquantr116 ** 0..*
+    set_addr $I10, rxquantr116_done
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  rxquantr116_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I133)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I133)
-    goto rxquantr132_loop
-  rxquantr132_done:
-  alt134_0:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr116_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr116_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr116_loop
+  rxquantr116_done:
+  alt117_0:
 .annotate 'line', 63
-    set_addr $I10, alt134_1
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    set_addr $I10, alt117_1
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
   # rxanchor eol
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    if $I11, rxanchor135_done
-    ne rx105_pos, rx105_eos, rx105_fail
-    eq rx105_pos, 0, rxanchor135_done
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    if $I11, rxanchor118_done
+    ne rx96_pos, rx96_eos, rx96_fail
+    eq rx96_pos, 0, rxanchor118_done
     dec $I10
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    if $I11, rx105_fail
-  rxanchor135_done:
-    goto alt134_end
-  alt134_1:
-    set_addr $I10, alt134_2
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    if $I11, rx96_fail
+  rxanchor118_done:
+    goto alt117_end
+  alt117_1:
+    set_addr $I10, alt117_2
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
   # rx literal  "#"
-    add $I11, rx105_pos, 1
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 1
-    ne $S10, "#", rx105_fail
-    add rx105_pos, 1
-    goto alt134_end
-  alt134_2:
+    add $I11, rx96_pos, 1
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 1
+    ne $S10, "#", rx96_fail
+    add rx96_pos, 1
+    goto alt117_end
+  alt117_2:
   # rx subrule "panic" subtype=method negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."panic"("Unrecognized token after =begin")
-    unless $P10, rx105_fail
-    rx105_pos = $P10."pos"()
-  alt134_end:
-  alt136_0:
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."panic"("Unrecognized token after =begin")
+    unless $P10, rx96_fail
+    rx96_pos = $P10."pos"()
+  alt117_end:
+  alt119_0:
 .annotate 'line', 64
-    set_addr $I10, alt136_1
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    set_addr $I10, alt119_1
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
 .annotate 'line', 65
-  # rx rxquantf137 ** 0..*
-    set_addr $I10, rxquantf137_loop
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
-    goto rxquantf137_done
-  rxquantf137_loop:
+  # rx rxquantf120 ** 0..*
+    set_addr $I10, rxquantf120_loop
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+    goto rxquantf120_done
+  rxquantf120_loop:
   # rx charclass .
-    ge rx105_pos, rx105_eos, rx105_fail
-    inc rx105_pos
-    set_addr $I10, rxquantf137_loop
-    rx105_cur."!mark_push"($I138, rx105_pos, $I10)
-  rxquantf137_done:
+    ge rx96_pos, rx96_eos, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantf120_loop
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+  rxquantf120_done:
   # rx charclass nl
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    unless $I11, rx105_fail
-    substr $S10, rx105_tgt, $I10, 2
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    unless $I11, rx96_fail
+    substr $S10, rx96_tgt, $I10, 2
     iseq $I11, $S10, "\r\n"
-    add rx105_pos, $I11
-    inc rx105_pos
-  # rx rxquantr139 ** 0..*
-    set_addr $I140, rxquantr139_done
-    rx105_cur."!mark_push"(0, rx105_pos, $I140)
-  rxquantr139_loop:
+    add rx96_pos, $I11
+    inc rx96_pos
+  # rx rxquantr122 ** 0..*
+    set_addr $I10, rxquantr122_done
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+  rxquantr122_loop:
   # rx enumcharlist negate=0 
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I10, 1
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx105_fail
-    inc rx105_pos
-    (rx105_rep) = rx105_cur."!mark_commit"($I140)
-    rx105_cur."!mark_push"(rx105_rep, rx105_pos, $I140)
-    goto rxquantr139_loop
-  rxquantr139_done:
+    lt $I11, 0, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantr122_done
+    (rx96_rep) = rx96_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr122_done
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+    goto rxquantr122_loop
+  rxquantr122_done:
   # rx literal  "=end"
-    add $I11, rx105_pos, 4
-    gt $I11, rx105_eos, rx105_fail
-    sub $I11, rx105_pos, rx105_off
-    substr $S10, rx105_tgt, $I11, 4
-    ne $S10, "=end", rx105_fail
-    add rx105_pos, 4
+    add $I11, rx96_pos, 4
+    gt $I11, rx96_eos, rx96_fail
+    sub $I11, rx96_pos, rx96_off
+    substr $S10, rx96_tgt, $I11, 4
+    ne $S10, "=end", rx96_fail
+    add rx96_pos, 4
   # rxanchor rwb
-    le rx105_pos, 0, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    if $I11, rx105_fail
+    le rx96_pos, 0, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    if $I11, rx96_fail
     dec $I10
-    is_cclass $I11, 8192, rx105_tgt, $I10
-    unless $I11, rx105_fail
+    is_cclass $I11, 8192, rx96_tgt, $I10
+    unless $I11, rx96_fail
   # rx charclass_q N r 0..-1
-    sub $I10, rx105_pos, rx105_off
-    find_cclass $I11, 4096, rx105_tgt, $I10, rx105_eos
-    add rx105_pos, rx105_off, $I11
-    goto alt136_end
-  alt136_1:
+    sub $I10, rx96_pos, rx96_off
+    find_cclass $I11, 4096, rx96_tgt, $I10, rx96_eos
+    add rx96_pos, rx96_off, $I11
+    goto alt119_end
+  alt119_1:
 .annotate 'line', 66
   # rx subrule "panic" subtype=method negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."panic"("=begin without matching =end")
-    unless $P10, rx105_fail
-    rx105_pos = $P10."pos"()
-  alt136_end:
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."panic"("=begin without matching =end")
+    unless $P10, rx96_fail
+    rx96_pos = $P10."pos"()
+  alt119_end:
 .annotate 'line', 62
-    goto alt112_end
-  alt112_3:
-    set_addr $I10, alt112_4
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    goto alt102_end
+  alt102_3:
+    set_addr $I10, alt102_4
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
 .annotate 'line', 68
   # rx subrule "identifier" subtype=capture negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."identifier"()
-    unless $P10, rx105_fail
-    rx105_cur."!mark_push"(0, -1, 0, $P10)
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."identifier"()
+    unless $P10, rx96_fail
+    rx96_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("identifier")
-    rx105_pos = $P10."pos"()
+    rx96_pos = $P10."pos"()
 .annotate 'line', 69
-  # rx rxquantf141 ** 0..*
-    set_addr $I10, rxquantf141_loop
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
-    goto rxquantf141_done
-  rxquantf141_loop:
+  # rx rxquantf123 ** 0..*
+    set_addr $I10, rxquantf123_loop
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
+    goto rxquantf123_done
+  rxquantf123_loop:
   # rx charclass .
-    ge rx105_pos, rx105_eos, rx105_fail
-    inc rx105_pos
-    set_addr $I10, rxquantf141_loop
-    rx105_cur."!mark_push"($I142, rx105_pos, $I10)
-  rxquantf141_done:
+    ge rx96_pos, rx96_eos, rx96_fail
+    inc rx96_pos
+    set_addr $I10, rxquantf123_loop
+    rx96_cur."!mark_push"(rx96_rep, rx96_pos, $I10)
+  rxquantf123_done:
   # rxanchor bol
-    eq rx105_pos, 0, rxanchor143_done
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
+    eq rx96_pos, 0, rxanchor125_done
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
     dec $I10
-    is_cclass $I11, 4096, rx105_tgt, $I10
-    unless $I11, rx105_fail
-  rxanchor143_done:
+    is_cclass $I11, 4096, rx96_tgt, $I10
+    unless $I11, rx96_fail
+  rxanchor125_done:
   # rx subrule "before" subtype=zerowidth negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    .const 'Sub' $P145 = "28_1278500537.15927" 
-    capture_lex $P145
-    $P10 = rx105_cur."before"($P145)
-    unless $P10, rx105_fail
+    rx96_cur."!cursor_pos"(rx96_pos)
+    .const 'Sub' $P127 = "28_1279529226.73787" 
+    capture_lex $P127
+    $P10 = rx96_cur."before"($P127)
+    unless $P10, rx96_fail
 .annotate 'line', 68
-    goto alt112_end
-  alt112_4:
-  alt153_0:
+    goto alt102_end
+  alt102_4:
+  alt133_0:
 .annotate 'line', 75
-    set_addr $I10, alt153_1
-    rx105_cur."!mark_push"(0, rx105_pos, $I10)
+    set_addr $I10, alt133_1
+    rx96_cur."!mark_push"(0, rx96_pos, $I10)
   # rx charclass s
-    ge rx105_pos, rx105_eos, rx105_fail
-    sub $I10, rx105_pos, rx105_off
-    is_cclass $I11, 32, rx105_tgt, $I10
-    unless $I11, rx105_fail
-    inc rx105_pos
-    goto alt153_end
-  alt153_1:
+    ge rx96_pos, rx96_eos, rx96_fail
+    sub $I10, rx96_pos, rx96_off
+    is_cclass $I11, 32, rx96_tgt, $I10
+    unless $I11, rx96_fail
+    inc rx96_pos
+    goto alt133_end
+  alt133_1:
   # rx subrule "panic" subtype=method negate=
-    rx105_cur."!cursor_pos"(rx105_pos)
-    $P10 = rx105_cur."panic"("Illegal pod directive")
-    unless $P10, rx105_fail
-    rx105_pos = $P10."pos"()
-  alt153_end:
+    rx96_cur."!cursor_pos"(rx96_pos)
+    $P10 = rx96_cur."panic"("Illegal pod directive")
+    unless $P10, rx96_fail
+    rx96_pos = $P10."pos"()
+  alt133_end:
 .annotate 'line', 76
   # rx charclass_q N r 0..-1
-    sub $I10, rx105_pos, rx105_off
-    find_cclass $I11, 4096, rx105_tgt, $I10, rx105_eos
-    add rx105_pos, rx105_off, $I11
-  alt112_end:
+    sub $I10, rx96_pos, rx96_off
+    find_cclass $I11, 4096, rx96_tgt, $I10, rx96_eos
+    add rx96_pos, rx96_off, $I11
+  alt102_end:
 .annotate 'line', 52
   # rx pass
-    rx105_cur."!cursor_pass"(rx105_pos, "pod_comment")
-    rx105_cur."!cursor_debug"("PASS  ", "pod_comment", " at pos=", rx105_pos)
-    .return (rx105_cur)
-  rx105_fail:
+    rx96_cur."!cursor_pass"(rx96_pos, "pod_comment")
+    rx96_cur."!cursor_debug"("PASS  ", "pod_comment", " at pos=", rx96_pos)
+    .return (rx96_cur)
+  rx96_restart:
 .annotate 'line', 4
-    (rx105_rep, rx105_pos, $I10, $P10) = rx105_cur."!mark_fail"(0)
-    lt rx105_pos, -1, rx105_done
-    eq rx105_pos, -1, rx105_fail
+    rx96_cur."!cursor_debug"("NEXT ", "pod_comment")
+  rx96_fail:
+    (rx96_rep, rx96_pos, $I10, $P10) = rx96_cur."!mark_fail"(0)
+    lt rx96_pos, -1, rx96_done
+    eq rx96_pos, -1, rx96_fail
     jump $I10
-  rx105_done:
-    rx105_cur."!cursor_fail"()
-    rx105_cur."!cursor_debug"("FAIL  ", "pod_comment")
-    .return (rx105_cur)
+  rx96_done:
+    rx96_cur."!cursor_fail"()
+    rx96_cur."!cursor_debug"("FAIL  ", "pod_comment")
+    .return (rx96_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__pod_comment"  :subid("27_1278500537.15927") :method
+.sub "!PREFIX__pod_comment"  :subid("27_1279529226.73787") :method
 .annotate 'line', 4
-    new $P107, "ResizablePMCArray"
-    push $P107, ""
-    .return ($P107)
+    new $P98, "ResizablePMCArray"
+    push $P98, ""
+    .return ($P98)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block144"  :anon :subid("28_1278500537.15927") :method :outer("26_1278500537.15927")
+.sub "_block126"  :anon :subid("28_1279529226.73787") :method :outer("26_1279529226.73787")
 .annotate 'line', 69
-    .local string rx146_tgt
-    .local int rx146_pos
-    .local int rx146_off
-    .local int rx146_eos
-    .local int rx146_rep
-    .local pmc rx146_cur
-    (rx146_cur, rx146_pos, rx146_tgt) = self."!cursor_start"()
-    rx146_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx146_cur
-    .local pmc match
-    .lex "$/", match
-    length rx146_eos, rx146_tgt
-    gt rx146_pos, rx146_eos, rx146_done
-    set rx146_off, 0
-    lt rx146_pos, 2, rx146_start
-    sub rx146_off, rx146_pos, 1
-    substr rx146_tgt, rx146_tgt, rx146_off
-  rx146_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan147_done
-    goto rxscan147_scan
-  rxscan147_loop:
-    ($P10) = rx146_cur."from"()
-    inc $P10
-    set rx146_pos, $P10
-    ge rx146_pos, rx146_eos, rxscan147_done
-  rxscan147_scan:
-    set_addr $I10, rxscan147_loop
-    rx146_cur."!mark_push"(0, rx146_pos, $I10)
-  rxscan147_done:
-  # rx rxquantr148 ** 0..*
-    set_addr $I149, rxquantr148_done
-    rx146_cur."!mark_push"(0, rx146_pos, $I149)
-  rxquantr148_loop:
+    .local string rx128_tgt
+    .local int rx128_pos
+    .local int rx128_off
+    .local int rx128_eos
+    .local int rx128_rep
+    .local pmc rx128_cur
+    (rx128_cur, rx128_pos, rx128_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx128_cur
+    .local pmc match
+    .lex "$/", match
+    length rx128_eos, rx128_tgt
+    gt rx128_pos, rx128_eos, rx128_done
+    set rx128_off, 0
+    lt rx128_pos, 2, rx128_start
+    sub rx128_off, rx128_pos, 1
+    substr rx128_tgt, rx128_tgt, rx128_off
+  rx128_start:
+    eq $I10, 1, rx128_restart
+    rx128_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan129_done
+    goto rxscan129_scan
+  rxscan129_loop:
+    ($P10) = rx128_cur."from"()
+    inc $P10
+    set rx128_pos, $P10
+    ge rx128_pos, rx128_eos, rxscan129_done
+  rxscan129_scan:
+    set_addr $I10, rxscan129_loop
+    rx128_cur."!mark_push"(0, rx128_pos, $I10)
+  rxscan129_done:
+  # rx rxquantr130 ** 0..*
+    set_addr $I10, rxquantr130_done
+    rx128_cur."!mark_push"(0, rx128_pos, $I10)
+  rxquantr130_loop:
   # rx enumcharlist negate=0 
-    ge rx146_pos, rx146_eos, rx146_fail
-    sub $I10, rx146_pos, rx146_off
-    substr $S10, rx146_tgt, $I10, 1
+    ge rx128_pos, rx128_eos, rx128_fail
+    sub $I10, rx128_pos, rx128_off
+    substr $S10, rx128_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx146_fail
-    inc rx146_pos
-    (rx146_rep) = rx146_cur."!mark_commit"($I149)
-    rx146_cur."!mark_push"(rx146_rep, rx146_pos, $I149)
-    goto rxquantr148_loop
-  rxquantr148_done:
-  alt150_0:
-    set_addr $I10, alt150_1
-    rx146_cur."!mark_push"(0, rx146_pos, $I10)
+    lt $I11, 0, rx128_fail
+    inc rx128_pos
+    set_addr $I10, rxquantr130_done
+    (rx128_rep) = rx128_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr130_done
+    rx128_cur."!mark_push"(rx128_rep, rx128_pos, $I10)
+    goto rxquantr130_loop
+  rxquantr130_done:
+  alt131_0:
+    set_addr $I10, alt131_1
+    rx128_cur."!mark_push"(0, rx128_pos, $I10)
 .annotate 'line', 70
   # rx literal  "="
-    add $I11, rx146_pos, 1
-    gt $I11, rx146_eos, rx146_fail
-    sub $I11, rx146_pos, rx146_off
-    substr $S10, rx146_tgt, $I11, 1
-    ne $S10, "=", rx146_fail
-    add rx146_pos, 1
+    add $I11, rx128_pos, 1
+    gt $I11, rx128_eos, rx128_fail
+    sub $I11, rx128_pos, rx128_off
+    substr $S10, rx128_tgt, $I11, 1
+    ne $S10, "=", rx128_fail
+    add rx128_pos, 1
 .annotate 'line', 72
-  # rx rxquantr151 ** 0..1
-    set_addr $I152, rxquantr151_done
-    rx146_cur."!mark_push"(0, rx146_pos, $I152)
-  rxquantr151_loop:
+  # rx rxquantr132 ** 0..1
+    set_addr $I10, rxquantr132_done
+    rx128_cur."!mark_push"(0, rx128_pos, $I10)
+  rxquantr132_loop:
 .annotate 'line', 71
   # rx literal  "cut"
-    add $I11, rx146_pos, 3
-    gt $I11, rx146_eos, rx146_fail
-    sub $I11, rx146_pos, rx146_off
-    substr $S10, rx146_tgt, $I11, 3
-    ne $S10, "cut", rx146_fail
-    add rx146_pos, 3
+    add $I11, rx128_pos, 3
+    gt $I11, rx128_eos, rx128_fail
+    sub $I11, rx128_pos, rx128_off
+    substr $S10, rx128_tgt, $I11, 3
+    ne $S10, "cut", rx128_fail
+    add rx128_pos, 3
   # rxanchor rwb
-    le rx146_pos, 0, rx146_fail
-    sub $I10, rx146_pos, rx146_off
-    is_cclass $I11, 8192, rx146_tgt, $I10
-    if $I11, rx146_fail
+    le rx128_pos, 0, rx128_fail
+    sub $I10, rx128_pos, rx128_off
+    is_cclass $I11, 8192, rx128_tgt, $I10
+    if $I11, rx128_fail
     dec $I10
-    is_cclass $I11, 8192, rx146_tgt, $I10
-    unless $I11, rx146_fail
+    is_cclass $I11, 8192, rx128_tgt, $I10
+    unless $I11, rx128_fail
 .annotate 'line', 72
   # rx subrule "panic" subtype=method negate=
-    rx146_cur."!cursor_pos"(rx146_pos)
-    $P10 = rx146_cur."panic"("Obsolete pod format, please use =begin/=end instead")
-    unless $P10, rx146_fail
-    rx146_pos = $P10."pos"()
-    (rx146_rep) = rx146_cur."!mark_commit"($I152)
-  rxquantr151_done:
+    rx128_cur."!cursor_pos"(rx128_pos)
+    $P10 = rx128_cur."panic"("Obsolete pod format, please use =begin/=end instead")
+    unless $P10, rx128_fail
+    rx128_pos = $P10."pos"()
+    set_addr $I10, rxquantr132_done
+    (rx128_rep) = rx128_cur."!mark_commit"($I10)
+  rxquantr132_done:
 .annotate 'line', 69
-    goto alt150_end
-  alt150_1:
+    goto alt131_end
+  alt131_1:
 .annotate 'line', 73
   # rx charclass nl
-    ge rx146_pos, rx146_eos, rx146_fail
-    sub $I10, rx146_pos, rx146_off
-    is_cclass $I11, 4096, rx146_tgt, $I10
-    unless $I11, rx146_fail
-    substr $S10, rx146_tgt, $I10, 2
+    ge rx128_pos, rx128_eos, rx128_fail
+    sub $I10, rx128_pos, rx128_off
+    is_cclass $I11, 4096, rx128_tgt, $I10
+    unless $I11, rx128_fail
+    substr $S10, rx128_tgt, $I10, 2
     iseq $I11, $S10, "\r\n"
-    add rx146_pos, $I11
-    inc rx146_pos
-  alt150_end:
+    add rx128_pos, $I11
+    inc rx128_pos
+  alt131_end:
 .annotate 'line', 69
   # rx pass
-    rx146_cur."!cursor_pass"(rx146_pos, "")
-    rx146_cur."!cursor_debug"("PASS  ", "", " at pos=", rx146_pos)
-    .return (rx146_cur)
-  rx146_fail:
-    (rx146_rep, rx146_pos, $I10, $P10) = rx146_cur."!mark_fail"(0)
-    lt rx146_pos, -1, rx146_done
-    eq rx146_pos, -1, rx146_fail
-    jump $I10
-  rx146_done:
-    rx146_cur."!cursor_fail"()
-    rx146_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx146_cur)
+    rx128_cur."!cursor_pass"(rx128_pos, "")
+    rx128_cur."!cursor_debug"("PASS  ", "", " at pos=", rx128_pos)
+    .return (rx128_cur)
+  rx128_restart:
+    rx128_cur."!cursor_debug"("NEXT ", "")
+  rx128_fail:
+    (rx128_rep, rx128_pos, $I10, $P10) = rx128_cur."!mark_fail"(0)
+    lt rx128_pos, -1, rx128_done
+    eq rx128_pos, -1, rx128_fail
+    jump $I10
+  rx128_done:
+    rx128_cur."!cursor_fail"()
+    rx128_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx128_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "comp_unit"  :subid("29_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx155_tgt
-    .local int rx155_pos
-    .local int rx155_off
-    .local int rx155_eos
-    .local int rx155_rep
-    .local pmc rx155_cur
-    (rx155_cur, rx155_pos, rx155_tgt) = self."!cursor_start"()
-    rx155_cur."!cursor_debug"("START ", "comp_unit")
-    .lex unicode:"$\x{a2}", rx155_cur
-    .local pmc match
-    .lex "$/", match
-    length rx155_eos, rx155_tgt
-    gt rx155_pos, rx155_eos, rx155_done
-    set rx155_off, 0
-    lt rx155_pos, 2, rx155_start
-    sub rx155_off, rx155_pos, 1
-    substr rx155_tgt, rx155_tgt, rx155_off
-  rx155_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan159_done
-    goto rxscan159_scan
-  rxscan159_loop:
-    ($P10) = rx155_cur."from"()
-    inc $P10
-    set rx155_pos, $P10
-    ge rx155_pos, rx155_eos, rxscan159_done
-  rxscan159_scan:
-    set_addr $I10, rxscan159_loop
-    rx155_cur."!mark_push"(0, rx155_pos, $I10)
-  rxscan159_done:
+.sub "comp_unit"  :subid("29_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx135_tgt
+    .local int rx135_pos
+    .local int rx135_off
+    .local int rx135_eos
+    .local int rx135_rep
+    .local pmc rx135_cur
+    (rx135_cur, rx135_pos, rx135_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx135_cur
+    .local pmc match
+    .lex "$/", match
+    length rx135_eos, rx135_tgt
+    gt rx135_pos, rx135_eos, rx135_done
+    set rx135_off, 0
+    lt rx135_pos, 2, rx135_start
+    sub rx135_off, rx135_pos, 1
+    substr rx135_tgt, rx135_tgt, rx135_off
+  rx135_start:
+    eq $I10, 1, rx135_restart
+    rx135_cur."!cursor_debug"("START ", "comp_unit")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan139_done
+    goto rxscan139_scan
+  rxscan139_loop:
+    ($P10) = rx135_cur."from"()
+    inc $P10
+    set rx135_pos, $P10
+    ge rx135_pos, rx135_eos, rxscan139_done
+  rxscan139_scan:
+    set_addr $I10, rxscan139_loop
+    rx135_cur."!mark_push"(0, rx135_pos, $I10)
+  rxscan139_done:
 .annotate 'line', 84
   # rx subrule "newpad" subtype=method negate=
-    rx155_cur."!cursor_pos"(rx155_pos)
-    $P10 = rx155_cur."newpad"()
-    unless $P10, rx155_fail
-    rx155_pos = $P10."pos"()
+    rx135_cur."!cursor_pos"(rx135_pos)
+    $P10 = rx135_cur."newpad"()
+    unless $P10, rx135_fail
+    rx135_pos = $P10."pos"()
 .annotate 'line', 85
   # rx subrule "outerctx" subtype=method negate=
-    rx155_cur."!cursor_pos"(rx155_pos)
-    $P10 = rx155_cur."outerctx"()
-    unless $P10, rx155_fail
-    rx155_pos = $P10."pos"()
+    rx135_cur."!cursor_pos"(rx135_pos)
+    $P10 = rx135_cur."outerctx"()
+    unless $P10, rx135_fail
+    rx135_pos = $P10."pos"()
 .annotate 'line', 86
   # rx subrule "statementlist" subtype=capture negate=
-    rx155_cur."!cursor_pos"(rx155_pos)
-    $P10 = rx155_cur."statementlist"()
-    unless $P10, rx155_fail
-    rx155_cur."!mark_push"(0, -1, 0, $P10)
+    rx135_cur."!cursor_pos"(rx135_pos)
+    $P10 = rx135_cur."statementlist"()
+    unless $P10, rx135_fail
+    rx135_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("statementlist")
-    rx155_pos = $P10."pos"()
-  alt160_0:
+    rx135_pos = $P10."pos"()
+  alt140_0:
 .annotate 'line', 87
-    set_addr $I10, alt160_1
-    rx155_cur."!mark_push"(0, rx155_pos, $I10)
+    set_addr $I10, alt140_1
+    rx135_cur."!mark_push"(0, rx135_pos, $I10)
   # rxanchor eos
-    ne rx155_pos, rx155_eos, rx155_fail
-    goto alt160_end
-  alt160_1:
+    ne rx135_pos, rx135_eos, rx135_fail
+    goto alt140_end
+  alt140_1:
   # rx subrule "panic" subtype=method negate=
-    rx155_cur."!cursor_pos"(rx155_pos)
-    $P10 = rx155_cur."panic"("Confused")
-    unless $P10, rx155_fail
-    rx155_pos = $P10."pos"()
-  alt160_end:
+    rx135_cur."!cursor_pos"(rx135_pos)
+    $P10 = rx135_cur."panic"("Confused")
+    unless $P10, rx135_fail
+    rx135_pos = $P10."pos"()
+  alt140_end:
 .annotate 'line', 83
   # rx pass
-    rx155_cur."!cursor_pass"(rx155_pos, "comp_unit")
-    rx155_cur."!cursor_debug"("PASS  ", "comp_unit", " at pos=", rx155_pos)
-    .return (rx155_cur)
-  rx155_fail:
+    rx135_cur."!cursor_pass"(rx135_pos, "comp_unit")
+    rx135_cur."!cursor_debug"("PASS  ", "comp_unit", " at pos=", rx135_pos)
+    .return (rx135_cur)
+  rx135_restart:
+.annotate 'line', 4
+    rx135_cur."!cursor_debug"("NEXT ", "comp_unit")
+  rx135_fail:
+    (rx135_rep, rx135_pos, $I10, $P10) = rx135_cur."!mark_fail"(0)
+    lt rx135_pos, -1, rx135_done
+    eq rx135_pos, -1, rx135_fail
+    jump $I10
+  rx135_done:
+    rx135_cur."!cursor_fail"()
+    rx135_cur."!cursor_debug"("FAIL  ", "comp_unit")
+    .return (rx135_cur)
+    .return ()
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "!PREFIX__comp_unit"  :subid("30_1279529226.73787") :method
+.annotate 'line', 4
+    $P137 = self."!PREFIX__!subrule"("newpad", "")
+    new $P138, "ResizablePMCArray"
+    push $P138, $P137
+    .return ($P138)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "statementlist"  :subid("31_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx142_tgt
+    .local int rx142_pos
+    .local int rx142_off
+    .local int rx142_eos
+    .local int rx142_rep
+    .local pmc rx142_cur
+    (rx142_cur, rx142_pos, rx142_tgt, $I10) = self."!cursor_start"()
+    rx142_cur."!cursor_caparray"("statement")
+    .lex unicode:"$\x{a2}", rx142_cur
+    .local pmc match
+    .lex "$/", match
+    length rx142_eos, rx142_tgt
+    gt rx142_pos, rx142_eos, rx142_done
+    set rx142_off, 0
+    lt rx142_pos, 2, rx142_start
+    sub rx142_off, rx142_pos, 1
+    substr rx142_tgt, rx142_tgt, rx142_off
+  rx142_start:
+    eq $I10, 1, rx142_restart
+    rx142_cur."!cursor_debug"("START ", "statementlist")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan147_done
+    goto rxscan147_scan
+  rxscan147_loop:
+    ($P10) = rx142_cur."from"()
+    inc $P10
+    set rx142_pos, $P10
+    ge rx142_pos, rx142_eos, rxscan147_done
+  rxscan147_scan:
+    set_addr $I10, rxscan147_loop
+    rx142_cur."!mark_push"(0, rx142_pos, $I10)
+  rxscan147_done:
+  alt148_0:
+.annotate 'line', 90
+    set_addr $I10, alt148_1
+    rx142_cur."!mark_push"(0, rx142_pos, $I10)
+.annotate 'line', 91
+  # rx subrule "ws" subtype=method negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."ws"()
+    unless $P10, rx142_fail
+    rx142_pos = $P10."pos"()
+  # rxanchor eos
+    ne rx142_pos, rx142_eos, rx142_fail
+  # rx subrule "ws" subtype=method negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."ws"()
+    unless $P10, rx142_fail
+    rx142_pos = $P10."pos"()
+    goto alt148_end
+  alt148_1:
+.annotate 'line', 92
+  # rx subrule "ws" subtype=method negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."ws"()
+    unless $P10, rx142_fail
+    rx142_pos = $P10."pos"()
+  # rx rxquantr152 ** 0..*
+    set_addr $I10, rxquantr152_done
+    rx142_cur."!mark_push"(0, rx142_pos, $I10)
+  rxquantr152_loop:
+  # rx subrule "statement" subtype=capture negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."statement"()
+    unless $P10, rx142_fail
+    rx142_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("statement")
+    rx142_pos = $P10."pos"()
+  # rx subrule "eat_terminator" subtype=method negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."eat_terminator"()
+    unless $P10, rx142_fail
+    rx142_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."ws"()
+    unless $P10, rx142_fail
+    rx142_pos = $P10."pos"()
+    set_addr $I10, rxquantr152_done
+    (rx142_rep) = rx142_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr152_done
+    rx142_cur."!mark_push"(rx142_rep, rx142_pos, $I10)
+    goto rxquantr152_loop
+  rxquantr152_done:
+  # rx subrule "ws" subtype=method negate=
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."ws"()
+    unless $P10, rx142_fail
+    rx142_pos = $P10."pos"()
+  alt148_end:
+.annotate 'line', 90
+  # rx pass
+    rx142_cur."!cursor_pass"(rx142_pos, "statementlist")
+    rx142_cur."!cursor_debug"("PASS  ", "statementlist", " at pos=", rx142_pos)
+    .return (rx142_cur)
+  rx142_restart:
+.annotate 'line', 4
+    rx142_cur."!cursor_debug"("NEXT ", "statementlist")
+  rx142_fail:
+    (rx142_rep, rx142_pos, $I10, $P10) = rx142_cur."!mark_fail"(0)
+    lt rx142_pos, -1, rx142_done
+    eq rx142_pos, -1, rx142_fail
+    jump $I10
+  rx142_done:
+    rx142_cur."!cursor_fail"()
+    rx142_cur."!cursor_debug"("FAIL  ", "statementlist")
+    .return (rx142_cur)
+    .return ()
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "!PREFIX__statementlist"  :subid("32_1279529226.73787") :method
+.annotate 'line', 4
+    $P144 = self."!PREFIX__!subrule"("ws", "")
+    $P145 = self."!PREFIX__!subrule"("ws", "")
+    new $P146, "ResizablePMCArray"
+    push $P146, $P144
+    push $P146, $P145
+    .return ($P146)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "statement"  :subid("33_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .const 'Sub' $P161 = "35_1279529226.73787" 
+    capture_lex $P161
+    .local string rx156_tgt
+    .local int rx156_pos
+    .local int rx156_off
+    .local int rx156_eos
+    .local int rx156_rep
+    .local pmc rx156_cur
+    (rx156_cur, rx156_pos, rx156_tgt, $I10) = self."!cursor_start"()
+    rx156_cur."!cursor_caparray"("statement_mod_loop", "statement_mod_cond")
+    .lex unicode:"$\x{a2}", rx156_cur
+    .local pmc match
+    .lex "$/", match
+    length rx156_eos, rx156_tgt
+    gt rx156_pos, rx156_eos, rx156_done
+    set rx156_off, 0
+    lt rx156_pos, 2, rx156_start
+    sub rx156_off, rx156_pos, 1
+    substr rx156_tgt, rx156_tgt, rx156_off
+  rx156_start:
+    eq $I10, 1, rx156_restart
+    rx156_cur."!cursor_debug"("START ", "statement")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan159_done
+    goto rxscan159_scan
+  rxscan159_loop:
+    ($P10) = rx156_cur."from"()
+    inc $P10
+    set rx156_pos, $P10
+    ge rx156_pos, rx156_eos, rxscan159_done
+  rxscan159_scan:
+    set_addr $I10, rxscan159_loop
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxscan159_done:
+.annotate 'line', 96
+  # rx subrule "before" subtype=zerowidth negate=1
+    rx156_cur."!cursor_pos"(rx156_pos)
+    .const 'Sub' $P161 = "35_1279529226.73787" 
+    capture_lex $P161
+    $P10 = rx156_cur."before"($P161)
+    if $P10, rx156_fail
+  alt165_0:
+.annotate 'line', 97
+    set_addr $I10, alt165_1
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+.annotate 'line', 98
+  # rx subrule "statement_control" subtype=capture negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."statement_control"()
+    unless $P10, rx156_fail
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("statement_control")
+    rx156_pos = $P10."pos"()
+    goto alt165_end
+  alt165_1:
+.annotate 'line', 99
+  # rx subrule "EXPR" subtype=capture negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."EXPR"()
+    unless $P10, rx156_fail
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("EXPR")
+    rx156_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."ws"()
+    unless $P10, rx156_fail
+    rx156_pos = $P10."pos"()
+.annotate 'line', 104
+  # rx rxquantr166 ** 0..1
+    set_addr $I10, rxquantr166_done
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxquantr166_loop:
+  alt167_0:
+.annotate 'line', 100
+    set_addr $I10, alt167_1
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+.annotate 'line', 101
+  # rx subrule "MARKED" subtype=zerowidth negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."MARKED"("endstmt")
+    unless $P10, rx156_fail
+    goto alt167_end
+  alt167_1:
+    set_addr $I10, alt167_2
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+.annotate 'line', 102
+  # rx subrule "statement_mod_cond" subtype=capture negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."statement_mod_cond"()
+    unless $P10, rx156_fail
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("statement_mod_cond")
+    rx156_pos = $P10."pos"()
+  # rx rxquantr168 ** 0..1
+    set_addr $I10, rxquantr168_done
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxquantr168_loop:
+  # rx subrule "statement_mod_loop" subtype=capture negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."statement_mod_loop"()
+    unless $P10, rx156_fail
+    goto rxsubrule169_pass
+  rxsubrule169_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx156_fail
+  rxsubrule169_pass:
+    set_addr $I10, rxsubrule169_back
+    rx156_cur."!mark_push"(0, rx156_pos, $I10, $P10)
+    $P10."!cursor_names"("statement_mod_loop")
+    rx156_pos = $P10."pos"()
+    set_addr $I10, rxquantr168_done
+    (rx156_rep) = rx156_cur."!mark_commit"($I10)
+  rxquantr168_done:
+    goto alt167_end
+  alt167_2:
+.annotate 'line', 103
+  # rx subrule "statement_mod_loop" subtype=capture negate=
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."statement_mod_loop"()
+    unless $P10, rx156_fail
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("statement_mod_loop")
+    rx156_pos = $P10."pos"()
+  alt167_end:
+.annotate 'line', 104
+    set_addr $I10, rxquantr166_done
+    (rx156_rep) = rx156_cur."!mark_commit"($I10)
+  rxquantr166_done:
+  alt165_end:
+.annotate 'line', 95
+  # rx pass
+    rx156_cur."!cursor_pass"(rx156_pos, "statement")
+    rx156_cur."!cursor_debug"("PASS  ", "statement", " at pos=", rx156_pos)
+    .return (rx156_cur)
+  rx156_restart:
 .annotate 'line', 4
-    (rx155_rep, rx155_pos, $I10, $P10) = rx155_cur."!mark_fail"(0)
-    lt rx155_pos, -1, rx155_done
-    eq rx155_pos, -1, rx155_fail
+    rx156_cur."!cursor_debug"("NEXT ", "statement")
+  rx156_fail:
+    (rx156_rep, rx156_pos, $I10, $P10) = rx156_cur."!mark_fail"(0)
+    lt rx156_pos, -1, rx156_done
+    eq rx156_pos, -1, rx156_fail
     jump $I10
-  rx155_done:
-    rx155_cur."!cursor_fail"()
-    rx155_cur."!cursor_debug"("FAIL  ", "comp_unit")
-    .return (rx155_cur)
+  rx156_done:
+    rx156_cur."!cursor_fail"()
+    rx156_cur."!cursor_debug"("FAIL  ", "statement")
+    .return (rx156_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__comp_unit"  :subid("30_1278500537.15927") :method
+.sub "!PREFIX__statement"  :subid("34_1279529226.73787") :method
 .annotate 'line', 4
-    $P157 = self."!PREFIX__!subrule"("newpad", "")
     new $P158, "ResizablePMCArray"
-    push $P158, $P157
+    push $P158, ""
     .return ($P158)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statementlist"  :subid("31_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
+.sub "_block160"  :anon :subid("35_1279529226.73787") :method :outer("33_1279529226.73787")
+.annotate 'line', 96
     .local string rx162_tgt
     .local int rx162_pos
     .local int rx162_off
     .local int rx162_eos
     .local int rx162_rep
     .local pmc rx162_cur
-    (rx162_cur, rx162_pos, rx162_tgt) = self."!cursor_start"()
-    rx162_cur."!cursor_debug"("START ", "statementlist")
-    rx162_cur."!cursor_caparray"("statement")
+    (rx162_cur, rx162_pos, rx162_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx162_cur
     .local pmc match
     .lex "$/", match
@@ -2110,119 +2488,167 @@
     sub rx162_off, rx162_pos, 1
     substr rx162_tgt, rx162_tgt, rx162_off
   rx162_start:
+    eq $I10, 1, rx162_restart
+    rx162_cur."!cursor_debug"("START ", "")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan167_done
-    goto rxscan167_scan
-  rxscan167_loop:
+    ne $I10, -1, rxscan163_done
+    goto rxscan163_scan
+  rxscan163_loop:
     ($P10) = rx162_cur."from"()
     inc $P10
     set rx162_pos, $P10
-    ge rx162_pos, rx162_eos, rxscan167_done
-  rxscan167_scan:
-    set_addr $I10, rxscan167_loop
+    ge rx162_pos, rx162_eos, rxscan163_done
+  rxscan163_scan:
+    set_addr $I10, rxscan163_loop
     rx162_cur."!mark_push"(0, rx162_pos, $I10)
-  rxscan167_done:
-  alt168_0:
-.annotate 'line', 90
-    set_addr $I10, alt168_1
+  rxscan163_done:
+  alt164_0:
+    set_addr $I10, alt164_1
     rx162_cur."!mark_push"(0, rx162_pos, $I10)
-.annotate 'line', 91
-  # rx subrule "ws" subtype=method negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."ws"()
-    unless $P10, rx162_fail
-    rx162_pos = $P10."pos"()
+  # rx enumcharlist negate=0 
+    ge rx162_pos, rx162_eos, rx162_fail
+    sub $I10, rx162_pos, rx162_off
+    substr $S10, rx162_tgt, $I10, 1
+    index $I11, "])}", $S10
+    lt $I11, 0, rx162_fail
+    inc rx162_pos
+    goto alt164_end
+  alt164_1:
   # rxanchor eos
     ne rx162_pos, rx162_eos, rx162_fail
-  # rx subrule "ws" subtype=method negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."ws"()
-    unless $P10, rx162_fail
-    rx162_pos = $P10."pos"()
-    goto alt168_end
-  alt168_1:
-.annotate 'line', 92
-  # rx subrule "ws" subtype=method negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."ws"()
-    unless $P10, rx162_fail
-    rx162_pos = $P10."pos"()
-  # rx rxquantr172 ** 0..*
-    set_addr $I174, rxquantr172_done
-    rx162_cur."!mark_push"(0, rx162_pos, $I174)
-  rxquantr172_loop:
-  # rx subrule "statement" subtype=capture negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."statement"()
-    unless $P10, rx162_fail
-    rx162_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("statement")
-    rx162_pos = $P10."pos"()
-  # rx subrule "eat_terminator" subtype=method negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."eat_terminator"()
-    unless $P10, rx162_fail
-    rx162_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."ws"()
-    unless $P10, rx162_fail
-    rx162_pos = $P10."pos"()
-    (rx162_rep) = rx162_cur."!mark_commit"($I174)
-    rx162_cur."!mark_push"(rx162_rep, rx162_pos, $I174)
-    goto rxquantr172_loop
-  rxquantr172_done:
-  # rx subrule "ws" subtype=method negate=
-    rx162_cur."!cursor_pos"(rx162_pos)
-    $P10 = rx162_cur."ws"()
-    unless $P10, rx162_fail
-    rx162_pos = $P10."pos"()
-  alt168_end:
-.annotate 'line', 90
+  alt164_end:
   # rx pass
-    rx162_cur."!cursor_pass"(rx162_pos, "statementlist")
-    rx162_cur."!cursor_debug"("PASS  ", "statementlist", " at pos=", rx162_pos)
+    rx162_cur."!cursor_pass"(rx162_pos, "")
+    rx162_cur."!cursor_debug"("PASS  ", "", " at pos=", rx162_pos)
     .return (rx162_cur)
+  rx162_restart:
+    rx162_cur."!cursor_debug"("NEXT ", "")
   rx162_fail:
-.annotate 'line', 4
     (rx162_rep, rx162_pos, $I10, $P10) = rx162_cur."!mark_fail"(0)
     lt rx162_pos, -1, rx162_done
     eq rx162_pos, -1, rx162_fail
     jump $I10
   rx162_done:
     rx162_cur."!cursor_fail"()
-    rx162_cur."!cursor_debug"("FAIL  ", "statementlist")
+    rx162_cur."!cursor_debug"("FAIL  ", "")
     .return (rx162_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statementlist"  :subid("32_1278500537.15927") :method
+.sub "eat_terminator"  :subid("36_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx171_tgt
+    .local int rx171_pos
+    .local int rx171_off
+    .local int rx171_eos
+    .local int rx171_rep
+    .local pmc rx171_cur
+    (rx171_cur, rx171_pos, rx171_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx171_cur
+    .local pmc match
+    .lex "$/", match
+    length rx171_eos, rx171_tgt
+    gt rx171_pos, rx171_eos, rx171_done
+    set rx171_off, 0
+    lt rx171_pos, 2, rx171_start
+    sub rx171_off, rx171_pos, 1
+    substr rx171_tgt, rx171_tgt, rx171_off
+  rx171_start:
+    eq $I10, 1, rx171_restart
+    rx171_cur."!cursor_debug"("START ", "eat_terminator")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan174_done
+    goto rxscan174_scan
+  rxscan174_loop:
+    ($P10) = rx171_cur."from"()
+    inc $P10
+    set rx171_pos, $P10
+    ge rx171_pos, rx171_eos, rxscan174_done
+  rxscan174_scan:
+    set_addr $I10, rxscan174_loop
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+  rxscan174_done:
+  alt175_0:
+.annotate 'line', 108
+    set_addr $I10, alt175_1
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+.annotate 'line', 109
+  # rx literal  ";"
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, ";", rx171_fail
+    add rx171_pos, 1
+    goto alt175_end
+  alt175_1:
+    set_addr $I10, alt175_2
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+.annotate 'line', 110
+  # rx subrule "MARKED" subtype=zerowidth negate=
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."MARKED"("endstmt")
+    unless $P10, rx171_fail
+    goto alt175_end
+  alt175_2:
+    set_addr $I10, alt175_3
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+.annotate 'line', 111
+  # rx subrule "terminator" subtype=zerowidth negate=
+    rx171_cur."!cursor_pos"(rx171_pos)
+    $P10 = rx171_cur."terminator"()
+    unless $P10, rx171_fail
+    goto alt175_end
+  alt175_3:
+.annotate 'line', 112
+  # rxanchor eos
+    ne rx171_pos, rx171_eos, rx171_fail
+  alt175_end:
+.annotate 'line', 108
+  # rx pass
+    rx171_cur."!cursor_pass"(rx171_pos, "eat_terminator")
+    rx171_cur."!cursor_debug"("PASS  ", "eat_terminator", " at pos=", rx171_pos)
+    .return (rx171_cur)
+  rx171_restart:
+.annotate 'line', 4
+    rx171_cur."!cursor_debug"("NEXT ", "eat_terminator")
+  rx171_fail:
+    (rx171_rep, rx171_pos, $I10, $P10) = rx171_cur."!mark_fail"(0)
+    lt rx171_pos, -1, rx171_done
+    eq rx171_pos, -1, rx171_fail
+    jump $I10
+  rx171_done:
+    rx171_cur."!cursor_fail"()
+    rx171_cur."!cursor_debug"("FAIL  ", "eat_terminator")
+    .return (rx171_cur)
+    .return ()
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "!PREFIX__eat_terminator"  :subid("37_1279529226.73787") :method
 .annotate 'line', 4
-    $P164 = self."!PREFIX__!subrule"("ws", "")
-    $P165 = self."!PREFIX__!subrule"("ws", "")
-    new $P166, "ResizablePMCArray"
-    push $P166, $P164
-    push $P166, $P165
-    .return ($P166)
+    new $P173, "ResizablePMCArray"
+    push $P173, ""
+    push $P173, ""
+    push $P173, ""
+    push $P173, ";"
+    .return ($P173)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement"  :subid("33_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "xblock"  :subid("38_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .const 'Sub' $P182 = "35_1278500537.15927" 
-    capture_lex $P182
     .local string rx177_tgt
     .local int rx177_pos
     .local int rx177_off
     .local int rx177_eos
     .local int rx177_rep
     .local pmc rx177_cur
-    (rx177_cur, rx177_pos, rx177_tgt) = self."!cursor_start"()
-    rx177_cur."!cursor_debug"("START ", "statement")
-    rx177_cur."!cursor_caparray"("statement_mod_cond", "statement_mod_loop")
+    (rx177_cur, rx177_pos, rx177_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx177_cur
     .local pmc match
     .lex "$/", match
@@ -2233,40 +2659,21 @@
     sub rx177_off, rx177_pos, 1
     substr rx177_tgt, rx177_tgt, rx177_off
   rx177_start:
+    eq $I10, 1, rx177_restart
+    rx177_cur."!cursor_debug"("START ", "xblock")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan180_done
-    goto rxscan180_scan
-  rxscan180_loop:
+    ne $I10, -1, rxscan181_done
+    goto rxscan181_scan
+  rxscan181_loop:
     ($P10) = rx177_cur."from"()
     inc $P10
     set rx177_pos, $P10
-    ge rx177_pos, rx177_eos, rxscan180_done
-  rxscan180_scan:
-    set_addr $I10, rxscan180_loop
-    rx177_cur."!mark_push"(0, rx177_pos, $I10)
-  rxscan180_done:
-.annotate 'line', 96
-  # rx subrule "before" subtype=zerowidth negate=1
-    rx177_cur."!cursor_pos"(rx177_pos)
-    .const 'Sub' $P182 = "35_1278500537.15927" 
-    capture_lex $P182
-    $P10 = rx177_cur."before"($P182)
-    if $P10, rx177_fail
-  alt186_0:
-.annotate 'line', 97
-    set_addr $I10, alt186_1
+    ge rx177_pos, rx177_eos, rxscan181_done
+  rxscan181_scan:
+    set_addr $I10, rxscan181_loop
     rx177_cur."!mark_push"(0, rx177_pos, $I10)
-.annotate 'line', 98
-  # rx subrule "statement_control" subtype=capture negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."statement_control"()
-    unless $P10, rx177_fail
-    rx177_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("statement_control")
-    rx177_pos = $P10."pos"()
-    goto alt186_end
-  alt186_1:
-.annotate 'line', 99
+  rxscan181_done:
+.annotate 'line', 116
   # rx subrule "EXPR" subtype=capture negate=
     rx177_cur."!cursor_pos"(rx177_pos)
     $P10 = rx177_cur."EXPR"()
@@ -2279,99 +2686,54 @@
     $P10 = rx177_cur."ws"()
     unless $P10, rx177_fail
     rx177_pos = $P10."pos"()
-.annotate 'line', 104
-  # rx rxquantr187 ** 0..1
-    set_addr $I191, rxquantr187_done
-    rx177_cur."!mark_push"(0, rx177_pos, $I191)
-  rxquantr187_loop:
-  alt188_0:
-.annotate 'line', 100
-    set_addr $I10, alt188_1
-    rx177_cur."!mark_push"(0, rx177_pos, $I10)
-.annotate 'line', 101
-  # rx subrule "MARKED" subtype=zerowidth negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."MARKED"("endstmt")
-    unless $P10, rx177_fail
-    goto alt188_end
-  alt188_1:
-    set_addr $I10, alt188_2
-    rx177_cur."!mark_push"(0, rx177_pos, $I10)
-.annotate 'line', 102
-  # rx subrule "statement_mod_cond" subtype=capture negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."statement_mod_cond"()
-    unless $P10, rx177_fail
-    rx177_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("statement_mod_cond")
-    rx177_pos = $P10."pos"()
-  # rx rxquantr189 ** 0..1
-    set_addr $I190, rxquantr189_done
-    rx177_cur."!mark_push"(0, rx177_pos, $I190)
-  rxquantr189_loop:
-  # rx subrule "statement_mod_loop" subtype=capture negate=
-    rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."statement_mod_loop"()
-    unless $P10, rx177_fail
-    rx177_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("statement_mod_loop")
-    rx177_pos = $P10."pos"()
-    (rx177_rep) = rx177_cur."!mark_commit"($I190)
-  rxquantr189_done:
-    goto alt188_end
-  alt188_2:
-.annotate 'line', 103
-  # rx subrule "statement_mod_loop" subtype=capture negate=
+  # rx subrule "pblock" subtype=capture negate=
     rx177_cur."!cursor_pos"(rx177_pos)
-    $P10 = rx177_cur."statement_mod_loop"()
+    $P10 = rx177_cur."pblock"()
     unless $P10, rx177_fail
     rx177_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("statement_mod_loop")
+    $P10."!cursor_names"("pblock")
     rx177_pos = $P10."pos"()
-  alt188_end:
-.annotate 'line', 104
-    (rx177_rep) = rx177_cur."!mark_commit"($I191)
-  rxquantr187_done:
-  alt186_end:
-.annotate 'line', 95
+.annotate 'line', 115
   # rx pass
-    rx177_cur."!cursor_pass"(rx177_pos, "statement")
-    rx177_cur."!cursor_debug"("PASS  ", "statement", " at pos=", rx177_pos)
+    rx177_cur."!cursor_pass"(rx177_pos, "xblock")
+    rx177_cur."!cursor_debug"("PASS  ", "xblock", " at pos=", rx177_pos)
     .return (rx177_cur)
-  rx177_fail:
+  rx177_restart:
 .annotate 'line', 4
+    rx177_cur."!cursor_debug"("NEXT ", "xblock")
+  rx177_fail:
     (rx177_rep, rx177_pos, $I10, $P10) = rx177_cur."!mark_fail"(0)
     lt rx177_pos, -1, rx177_done
     eq rx177_pos, -1, rx177_fail
     jump $I10
   rx177_done:
     rx177_cur."!cursor_fail"()
-    rx177_cur."!cursor_debug"("FAIL  ", "statement")
+    rx177_cur."!cursor_debug"("FAIL  ", "xblock")
     .return (rx177_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement"  :subid("34_1278500537.15927") :method
+.sub "!PREFIX__xblock"  :subid("39_1279529226.73787") :method
 .annotate 'line', 4
-    new $P179, "ResizablePMCArray"
-    push $P179, ""
-    .return ($P179)
+    $P179 = self."!PREFIX__!subrule"("EXPR", "")
+    new $P180, "ResizablePMCArray"
+    push $P180, $P179
+    .return ($P180)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block181"  :anon :subid("35_1278500537.15927") :method :outer("33_1278500537.15927")
-.annotate 'line', 96
+.sub "pblock"  :subid("40_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
     .local string rx183_tgt
     .local int rx183_pos
     .local int rx183_off
     .local int rx183_eos
     .local int rx183_rep
     .local pmc rx183_cur
-    (rx183_cur, rx183_pos, rx183_tgt) = self."!cursor_start"()
-    rx183_cur."!cursor_debug"("START ", "")
+    (rx183_cur, rx183_pos, rx183_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx183_cur
     .local pmc match
     .lex "$/", match
@@ -2382,6057 +2744,6403 @@
     sub rx183_off, rx183_pos, 1
     substr rx183_tgt, rx183_tgt, rx183_off
   rx183_start:
+    eq $I10, 1, rx183_restart
+    rx183_cur."!cursor_debug"("START ", "pblock")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan184_done
-    goto rxscan184_scan
-  rxscan184_loop:
+    ne $I10, -1, rxscan188_done
+    goto rxscan188_scan
+  rxscan188_loop:
     ($P10) = rx183_cur."from"()
     inc $P10
     set rx183_pos, $P10
-    ge rx183_pos, rx183_eos, rxscan184_done
-  rxscan184_scan:
-    set_addr $I10, rxscan184_loop
+    ge rx183_pos, rx183_eos, rxscan188_done
+  rxscan188_scan:
+    set_addr $I10, rxscan188_loop
     rx183_cur."!mark_push"(0, rx183_pos, $I10)
-  rxscan184_done:
-  alt185_0:
-    set_addr $I10, alt185_1
+  rxscan188_done:
+  alt189_0:
+.annotate 'line', 119
+    set_addr $I10, alt189_1
     rx183_cur."!mark_push"(0, rx183_pos, $I10)
-  # rx enumcharlist negate=0 
-    ge rx183_pos, rx183_eos, rx183_fail
-    sub $I10, rx183_pos, rx183_off
-    substr $S10, rx183_tgt, $I10, 1
-    index $I11, "])}", $S10
-    lt $I11, 0, rx183_fail
-    inc rx183_pos
-    goto alt185_end
-  alt185_1:
-  # rxanchor eos
-    ne rx183_pos, rx183_eos, rx183_fail
-  alt185_end:
-  # rx pass
-    rx183_cur."!cursor_pass"(rx183_pos, "")
-    rx183_cur."!cursor_debug"("PASS  ", "", " at pos=", rx183_pos)
-    .return (rx183_cur)
-  rx183_fail:
-    (rx183_rep, rx183_pos, $I10, $P10) = rx183_cur."!mark_fail"(0)
-    lt rx183_pos, -1, rx183_done
-    eq rx183_pos, -1, rx183_fail
-    jump $I10
-  rx183_done:
-    rx183_cur."!cursor_fail"()
-    rx183_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx183_cur)
-    .return ()
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "eat_terminator"  :subid("36_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx193_tgt
-    .local int rx193_pos
-    .local int rx193_off
-    .local int rx193_eos
-    .local int rx193_rep
-    .local pmc rx193_cur
-    (rx193_cur, rx193_pos, rx193_tgt) = self."!cursor_start"()
-    rx193_cur."!cursor_debug"("START ", "eat_terminator")
-    .lex unicode:"$\x{a2}", rx193_cur
-    .local pmc match
-    .lex "$/", match
-    length rx193_eos, rx193_tgt
-    gt rx193_pos, rx193_eos, rx193_done
-    set rx193_off, 0
-    lt rx193_pos, 2, rx193_start
-    sub rx193_off, rx193_pos, 1
-    substr rx193_tgt, rx193_tgt, rx193_off
-  rx193_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan196_done
-    goto rxscan196_scan
-  rxscan196_loop:
-    ($P10) = rx193_cur."from"()
-    inc $P10
-    set rx193_pos, $P10
-    ge rx193_pos, rx193_eos, rxscan196_done
-  rxscan196_scan:
-    set_addr $I10, rxscan196_loop
-    rx193_cur."!mark_push"(0, rx193_pos, $I10)
-  rxscan196_done:
-  alt197_0:
-.annotate 'line', 108
-    set_addr $I10, alt197_1
-    rx193_cur."!mark_push"(0, rx193_pos, $I10)
-.annotate 'line', 109
-  # rx literal  ";"
-    add $I11, rx193_pos, 1
-    gt $I11, rx193_eos, rx193_fail
-    sub $I11, rx193_pos, rx193_off
-    substr $S10, rx193_tgt, $I11, 1
-    ne $S10, ";", rx193_fail
-    add rx193_pos, 1
-    goto alt197_end
-  alt197_1:
-    set_addr $I10, alt197_2
-    rx193_cur."!mark_push"(0, rx193_pos, $I10)
-.annotate 'line', 110
-  # rx subrule "MARKED" subtype=zerowidth negate=
-    rx193_cur."!cursor_pos"(rx193_pos)
-    $P10 = rx193_cur."MARKED"("endstmt")
-    unless $P10, rx193_fail
-    goto alt197_end
-  alt197_2:
-    set_addr $I10, alt197_3
-    rx193_cur."!mark_push"(0, rx193_pos, $I10)
-.annotate 'line', 111
-  # rx subrule "terminator" subtype=zerowidth negate=
-    rx193_cur."!cursor_pos"(rx193_pos)
-    $P10 = rx193_cur."terminator"()
-    unless $P10, rx193_fail
-    goto alt197_end
-  alt197_3:
-.annotate 'line', 112
-  # rxanchor eos
-    ne rx193_pos, rx193_eos, rx193_fail
-  alt197_end:
-.annotate 'line', 108
-  # rx pass
-    rx193_cur."!cursor_pass"(rx193_pos, "eat_terminator")
-    rx193_cur."!cursor_debug"("PASS  ", "eat_terminator", " at pos=", rx193_pos)
-    .return (rx193_cur)
-  rx193_fail:
-.annotate 'line', 4
-    (rx193_rep, rx193_pos, $I10, $P10) = rx193_cur."!mark_fail"(0)
-    lt rx193_pos, -1, rx193_done
-    eq rx193_pos, -1, rx193_fail
-    jump $I10
-  rx193_done:
-    rx193_cur."!cursor_fail"()
-    rx193_cur."!cursor_debug"("FAIL  ", "eat_terminator")
-    .return (rx193_cur)
-    .return ()
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "!PREFIX__eat_terminator"  :subid("37_1278500537.15927") :method
-.annotate 'line', 4
-    new $P195, "ResizablePMCArray"
-    push $P195, ""
-    push $P195, ""
-    push $P195, ""
-    push $P195, ";"
-    .return ($P195)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "xblock"  :subid("38_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx199_tgt
-    .local int rx199_pos
-    .local int rx199_off
-    .local int rx199_eos
-    .local int rx199_rep
-    .local pmc rx199_cur
-    (rx199_cur, rx199_pos, rx199_tgt) = self."!cursor_start"()
-    rx199_cur."!cursor_debug"("START ", "xblock")
-    .lex unicode:"$\x{a2}", rx199_cur
-    .local pmc match
-    .lex "$/", match
-    length rx199_eos, rx199_tgt
-    gt rx199_pos, rx199_eos, rx199_done
-    set rx199_off, 0
-    lt rx199_pos, 2, rx199_start
-    sub rx199_off, rx199_pos, 1
-    substr rx199_tgt, rx199_tgt, rx199_off
-  rx199_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan203_done
-    goto rxscan203_scan
-  rxscan203_loop:
-    ($P10) = rx199_cur."from"()
-    inc $P10
-    set rx199_pos, $P10
-    ge rx199_pos, rx199_eos, rxscan203_done
-  rxscan203_scan:
-    set_addr $I10, rxscan203_loop
-    rx199_cur."!mark_push"(0, rx199_pos, $I10)
-  rxscan203_done:
-.annotate 'line', 116
-  # rx subrule "EXPR" subtype=capture negate=
-    rx199_cur."!cursor_pos"(rx199_pos)
-    $P10 = rx199_cur."EXPR"()
-    unless $P10, rx199_fail
-    rx199_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("EXPR")
-    rx199_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx199_cur."!cursor_pos"(rx199_pos)
-    $P10 = rx199_cur."ws"()
-    unless $P10, rx199_fail
-    rx199_pos = $P10."pos"()
-  # rx subrule "pblock" subtype=capture negate=
-    rx199_cur."!cursor_pos"(rx199_pos)
-    $P10 = rx199_cur."pblock"()
-    unless $P10, rx199_fail
-    rx199_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("pblock")
-    rx199_pos = $P10."pos"()
-.annotate 'line', 115
-  # rx pass
-    rx199_cur."!cursor_pass"(rx199_pos, "xblock")
-    rx199_cur."!cursor_debug"("PASS  ", "xblock", " at pos=", rx199_pos)
-    .return (rx199_cur)
-  rx199_fail:
-.annotate 'line', 4
-    (rx199_rep, rx199_pos, $I10, $P10) = rx199_cur."!mark_fail"(0)
-    lt rx199_pos, -1, rx199_done
-    eq rx199_pos, -1, rx199_fail
-    jump $I10
-  rx199_done:
-    rx199_cur."!cursor_fail"()
-    rx199_cur."!cursor_debug"("FAIL  ", "xblock")
-    .return (rx199_cur)
-    .return ()
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "!PREFIX__xblock"  :subid("39_1278500537.15927") :method
-.annotate 'line', 4
-    $P201 = self."!PREFIX__!subrule"("EXPR", "")
-    new $P202, "ResizablePMCArray"
-    push $P202, $P201
-    .return ($P202)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "pblock"  :subid("40_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx205_tgt
-    .local int rx205_pos
-    .local int rx205_off
-    .local int rx205_eos
-    .local int rx205_rep
-    .local pmc rx205_cur
-    (rx205_cur, rx205_pos, rx205_tgt) = self."!cursor_start"()
-    rx205_cur."!cursor_debug"("START ", "pblock")
-    .lex unicode:"$\x{a2}", rx205_cur
-    .local pmc match
-    .lex "$/", match
-    length rx205_eos, rx205_tgt
-    gt rx205_pos, rx205_eos, rx205_done
-    set rx205_off, 0
-    lt rx205_pos, 2, rx205_start
-    sub rx205_off, rx205_pos, 1
-    substr rx205_tgt, rx205_tgt, rx205_off
-  rx205_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan210_done
-    goto rxscan210_scan
-  rxscan210_loop:
-    ($P10) = rx205_cur."from"()
-    inc $P10
-    set rx205_pos, $P10
-    ge rx205_pos, rx205_eos, rxscan210_done
-  rxscan210_scan:
-    set_addr $I10, rxscan210_loop
-    rx205_cur."!mark_push"(0, rx205_pos, $I10)
-  rxscan210_done:
-  alt211_0:
-.annotate 'line', 119
-    set_addr $I10, alt211_1
-    rx205_cur."!mark_push"(0, rx205_pos, $I10)
 .annotate 'line', 120
   # rx subrule "lambda" subtype=method negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."lambda"()
-    unless $P10, rx205_fail
-    rx205_pos = $P10."pos"()
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."lambda"()
+    unless $P10, rx183_fail
+    rx183_pos = $P10."pos"()
 .annotate 'line', 121
   # rx subrule "newpad" subtype=method negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."newpad"()
-    unless $P10, rx205_fail
-    rx205_pos = $P10."pos"()
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."newpad"()
+    unless $P10, rx183_fail
+    rx183_pos = $P10."pos"()
 .annotate 'line', 122
   # rx subrule "signature" subtype=capture negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."signature"()
-    unless $P10, rx205_fail
-    rx205_cur."!mark_push"(0, -1, 0, $P10)
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."signature"()
+    unless $P10, rx183_fail
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("signature")
-    rx205_pos = $P10."pos"()
+    rx183_pos = $P10."pos"()
 .annotate 'line', 123
   # rx subrule "blockoid" subtype=capture negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."blockoid"()
-    unless $P10, rx205_fail
-    rx205_cur."!mark_push"(0, -1, 0, $P10)
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."blockoid"()
+    unless $P10, rx183_fail
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blockoid")
-    rx205_pos = $P10."pos"()
+    rx183_pos = $P10."pos"()
 .annotate 'line', 120
-    goto alt211_end
-  alt211_1:
-    set_addr $I10, alt211_2
-    rx205_cur."!mark_push"(0, rx205_pos, $I10)
+    goto alt189_end
+  alt189_1:
+    set_addr $I10, alt189_2
+    rx183_cur."!mark_push"(0, rx183_pos, $I10)
 .annotate 'line', 124
   # rx enumcharlist negate=0 zerowidth
-    ge rx205_pos, rx205_eos, rx205_fail
-    sub $I10, rx205_pos, rx205_off
-    substr $S10, rx205_tgt, $I10, 1
+    ge rx183_pos, rx183_eos, rx183_fail
+    sub $I10, rx183_pos, rx183_off
+    substr $S10, rx183_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx205_fail
+    lt $I11, 0, rx183_fail
 .annotate 'line', 125
   # rx subrule "newpad" subtype=method negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."newpad"()
-    unless $P10, rx205_fail
-    rx205_pos = $P10."pos"()
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."newpad"()
+    unless $P10, rx183_fail
+    rx183_pos = $P10."pos"()
 .annotate 'line', 126
   # rx subrule "blockoid" subtype=capture negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."blockoid"()
-    unless $P10, rx205_fail
-    rx205_cur."!mark_push"(0, -1, 0, $P10)
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."blockoid"()
+    unless $P10, rx183_fail
+    rx183_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blockoid")
-    rx205_pos = $P10."pos"()
+    rx183_pos = $P10."pos"()
 .annotate 'line', 124
-    goto alt211_end
-  alt211_2:
+    goto alt189_end
+  alt189_2:
 .annotate 'line', 127
   # rx subrule "panic" subtype=method negate=
-    rx205_cur."!cursor_pos"(rx205_pos)
-    $P10 = rx205_cur."panic"("Missing block")
-    unless $P10, rx205_fail
-    rx205_pos = $P10."pos"()
-  alt211_end:
+    rx183_cur."!cursor_pos"(rx183_pos)
+    $P10 = rx183_cur."panic"("Missing block")
+    unless $P10, rx183_fail
+    rx183_pos = $P10."pos"()
+  alt189_end:
 .annotate 'line', 119
   # rx pass
-    rx205_cur."!cursor_pass"(rx205_pos, "pblock")
-    rx205_cur."!cursor_debug"("PASS  ", "pblock", " at pos=", rx205_pos)
-    .return (rx205_cur)
-  rx205_fail:
+    rx183_cur."!cursor_pass"(rx183_pos, "pblock")
+    rx183_cur."!cursor_debug"("PASS  ", "pblock", " at pos=", rx183_pos)
+    .return (rx183_cur)
+  rx183_restart:
 .annotate 'line', 4
-    (rx205_rep, rx205_pos, $I10, $P10) = rx205_cur."!mark_fail"(0)
-    lt rx205_pos, -1, rx205_done
-    eq rx205_pos, -1, rx205_fail
+    rx183_cur."!cursor_debug"("NEXT ", "pblock")
+  rx183_fail:
+    (rx183_rep, rx183_pos, $I10, $P10) = rx183_cur."!mark_fail"(0)
+    lt rx183_pos, -1, rx183_done
+    eq rx183_pos, -1, rx183_fail
     jump $I10
-  rx205_done:
-    rx205_cur."!cursor_fail"()
-    rx205_cur."!cursor_debug"("FAIL  ", "pblock")
-    .return (rx205_cur)
+  rx183_done:
+    rx183_cur."!cursor_fail"()
+    rx183_cur."!cursor_debug"("FAIL  ", "pblock")
+    .return (rx183_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__pblock"  :subid("41_1278500537.15927") :method
+.sub "!PREFIX__pblock"  :subid("41_1279529226.73787") :method
 .annotate 'line', 4
-    $P207 = self."!PREFIX__!subrule"("panic", "")
-    $P208 = self."!PREFIX__!subrule"("lambda", "")
-    new $P209, "ResizablePMCArray"
-    push $P209, $P207
-    push $P209, "{"
-    push $P209, $P208
-    .return ($P209)
+    $P185 = self."!PREFIX__!subrule"("panic", "")
+    $P186 = self."!PREFIX__!subrule"("lambda", "")
+    new $P187, "ResizablePMCArray"
+    push $P187, $P185
+    push $P187, "{"
+    push $P187, $P186
+    .return ($P187)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "lambda"  :subid("42_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx213_tgt
-    .local int rx213_pos
-    .local int rx213_off
-    .local int rx213_eos
-    .local int rx213_rep
-    .local pmc rx213_cur
-    (rx213_cur, rx213_pos, rx213_tgt) = self."!cursor_start"()
-    rx213_cur."!cursor_debug"("START ", "lambda")
-    .lex unicode:"$\x{a2}", rx213_cur
-    .local pmc match
-    .lex "$/", match
-    length rx213_eos, rx213_tgt
-    gt rx213_pos, rx213_eos, rx213_done
-    set rx213_off, 0
-    lt rx213_pos, 2, rx213_start
-    sub rx213_off, rx213_pos, 1
-    substr rx213_tgt, rx213_tgt, rx213_off
-  rx213_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan216_done
-    goto rxscan216_scan
-  rxscan216_loop:
-    ($P10) = rx213_cur."from"()
-    inc $P10
-    set rx213_pos, $P10
-    ge rx213_pos, rx213_eos, rxscan216_done
-  rxscan216_scan:
-    set_addr $I10, rxscan216_loop
-    rx213_cur."!mark_push"(0, rx213_pos, $I10)
-  rxscan216_done:
-  alt217_0:
+.sub "lambda"  :subid("42_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx191_tgt
+    .local int rx191_pos
+    .local int rx191_off
+    .local int rx191_eos
+    .local int rx191_rep
+    .local pmc rx191_cur
+    (rx191_cur, rx191_pos, rx191_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx191_cur
+    .local pmc match
+    .lex "$/", match
+    length rx191_eos, rx191_tgt
+    gt rx191_pos, rx191_eos, rx191_done
+    set rx191_off, 0
+    lt rx191_pos, 2, rx191_start
+    sub rx191_off, rx191_pos, 1
+    substr rx191_tgt, rx191_tgt, rx191_off
+  rx191_start:
+    eq $I10, 1, rx191_restart
+    rx191_cur."!cursor_debug"("START ", "lambda")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan194_done
+    goto rxscan194_scan
+  rxscan194_loop:
+    ($P10) = rx191_cur."from"()
+    inc $P10
+    set rx191_pos, $P10
+    ge rx191_pos, rx191_eos, rxscan194_done
+  rxscan194_scan:
+    set_addr $I10, rxscan194_loop
+    rx191_cur."!mark_push"(0, rx191_pos, $I10)
+  rxscan194_done:
+  alt195_0:
 .annotate 'line', 130
-    set_addr $I10, alt217_1
-    rx213_cur."!mark_push"(0, rx213_pos, $I10)
+    set_addr $I10, alt195_1
+    rx191_cur."!mark_push"(0, rx191_pos, $I10)
   # rx literal  "->"
-    add $I11, rx213_pos, 2
-    gt $I11, rx213_eos, rx213_fail
-    sub $I11, rx213_pos, rx213_off
-    substr $S10, rx213_tgt, $I11, 2
-    ne $S10, "->", rx213_fail
-    add rx213_pos, 2
-    goto alt217_end
-  alt217_1:
+    add $I11, rx191_pos, 2
+    gt $I11, rx191_eos, rx191_fail
+    sub $I11, rx191_pos, rx191_off
+    substr $S10, rx191_tgt, $I11, 2
+    ne $S10, "->", rx191_fail
+    add rx191_pos, 2
+    goto alt195_end
+  alt195_1:
   # rx literal  "<->"
-    add $I11, rx213_pos, 3
-    gt $I11, rx213_eos, rx213_fail
-    sub $I11, rx213_pos, rx213_off
-    substr $S10, rx213_tgt, $I11, 3
-    ne $S10, "<->", rx213_fail
-    add rx213_pos, 3
-  alt217_end:
-  # rx pass
-    rx213_cur."!cursor_pass"(rx213_pos, "lambda")
-    rx213_cur."!cursor_debug"("PASS  ", "lambda", " at pos=", rx213_pos)
-    .return (rx213_cur)
-  rx213_fail:
-.annotate 'line', 4
-    (rx213_rep, rx213_pos, $I10, $P10) = rx213_cur."!mark_fail"(0)
-    lt rx213_pos, -1, rx213_done
-    eq rx213_pos, -1, rx213_fail
-    jump $I10
-  rx213_done:
-    rx213_cur."!cursor_fail"()
-    rx213_cur."!cursor_debug"("FAIL  ", "lambda")
-    .return (rx213_cur)
+    add $I11, rx191_pos, 3
+    gt $I11, rx191_eos, rx191_fail
+    sub $I11, rx191_pos, rx191_off
+    substr $S10, rx191_tgt, $I11, 3
+    ne $S10, "<->", rx191_fail
+    add rx191_pos, 3
+  alt195_end:
+  # rx pass
+    rx191_cur."!cursor_pass"(rx191_pos, "lambda")
+    rx191_cur."!cursor_debug"("PASS  ", "lambda", " at pos=", rx191_pos)
+    .return (rx191_cur)
+  rx191_restart:
+.annotate 'line', 4
+    rx191_cur."!cursor_debug"("NEXT ", "lambda")
+  rx191_fail:
+    (rx191_rep, rx191_pos, $I10, $P10) = rx191_cur."!mark_fail"(0)
+    lt rx191_pos, -1, rx191_done
+    eq rx191_pos, -1, rx191_fail
+    jump $I10
+  rx191_done:
+    rx191_cur."!cursor_fail"()
+    rx191_cur."!cursor_debug"("FAIL  ", "lambda")
+    .return (rx191_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__lambda"  :subid("43_1278500537.15927") :method
-.annotate 'line', 4
-    new $P215, "ResizablePMCArray"
-    push $P215, "<->"
-    push $P215, "->"
-    .return ($P215)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "block"  :subid("44_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx219_tgt
-    .local int rx219_pos
-    .local int rx219_off
-    .local int rx219_eos
-    .local int rx219_rep
-    .local pmc rx219_cur
-    (rx219_cur, rx219_pos, rx219_tgt) = self."!cursor_start"()
-    rx219_cur."!cursor_debug"("START ", "block")
-    .lex unicode:"$\x{a2}", rx219_cur
-    .local pmc match
-    .lex "$/", match
-    length rx219_eos, rx219_tgt
-    gt rx219_pos, rx219_eos, rx219_done
-    set rx219_off, 0
-    lt rx219_pos, 2, rx219_start
-    sub rx219_off, rx219_pos, 1
-    substr rx219_tgt, rx219_tgt, rx219_off
-  rx219_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan223_done
-    goto rxscan223_scan
-  rxscan223_loop:
-    ($P10) = rx219_cur."from"()
-    inc $P10
-    set rx219_pos, $P10
-    ge rx219_pos, rx219_eos, rxscan223_done
-  rxscan223_scan:
-    set_addr $I10, rxscan223_loop
-    rx219_cur."!mark_push"(0, rx219_pos, $I10)
-  rxscan223_done:
-  alt224_0:
+.sub "!PREFIX__lambda"  :subid("43_1279529226.73787") :method
+.annotate 'line', 4
+    new $P193, "ResizablePMCArray"
+    push $P193, "<->"
+    push $P193, "->"
+    .return ($P193)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "block"  :subid("44_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx197_tgt
+    .local int rx197_pos
+    .local int rx197_off
+    .local int rx197_eos
+    .local int rx197_rep
+    .local pmc rx197_cur
+    (rx197_cur, rx197_pos, rx197_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx197_cur
+    .local pmc match
+    .lex "$/", match
+    length rx197_eos, rx197_tgt
+    gt rx197_pos, rx197_eos, rx197_done
+    set rx197_off, 0
+    lt rx197_pos, 2, rx197_start
+    sub rx197_off, rx197_pos, 1
+    substr rx197_tgt, rx197_tgt, rx197_off
+  rx197_start:
+    eq $I10, 1, rx197_restart
+    rx197_cur."!cursor_debug"("START ", "block")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan201_done
+    goto rxscan201_scan
+  rxscan201_loop:
+    ($P10) = rx197_cur."from"()
+    inc $P10
+    set rx197_pos, $P10
+    ge rx197_pos, rx197_eos, rxscan201_done
+  rxscan201_scan:
+    set_addr $I10, rxscan201_loop
+    rx197_cur."!mark_push"(0, rx197_pos, $I10)
+  rxscan201_done:
+  alt202_0:
 .annotate 'line', 133
-    set_addr $I10, alt224_1
-    rx219_cur."!mark_push"(0, rx219_pos, $I10)
+    set_addr $I10, alt202_1
+    rx197_cur."!mark_push"(0, rx197_pos, $I10)
   # rx enumcharlist negate=0 zerowidth
-    ge rx219_pos, rx219_eos, rx219_fail
-    sub $I10, rx219_pos, rx219_off
-    substr $S10, rx219_tgt, $I10, 1
+    ge rx197_pos, rx197_eos, rx197_fail
+    sub $I10, rx197_pos, rx197_off
+    substr $S10, rx197_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx219_fail
-    goto alt224_end
-  alt224_1:
+    lt $I11, 0, rx197_fail
+    goto alt202_end
+  alt202_1:
   # rx subrule "panic" subtype=method negate=
-    rx219_cur."!cursor_pos"(rx219_pos)
-    $P10 = rx219_cur."panic"("Missing block")
-    unless $P10, rx219_fail
-    rx219_pos = $P10."pos"()
-  alt224_end:
+    rx197_cur."!cursor_pos"(rx197_pos)
+    $P10 = rx197_cur."panic"("Missing block")
+    unless $P10, rx197_fail
+    rx197_pos = $P10."pos"()
+  alt202_end:
 .annotate 'line', 134
   # rx subrule "newpad" subtype=method negate=
-    rx219_cur."!cursor_pos"(rx219_pos)
-    $P10 = rx219_cur."newpad"()
-    unless $P10, rx219_fail
-    rx219_pos = $P10."pos"()
+    rx197_cur."!cursor_pos"(rx197_pos)
+    $P10 = rx197_cur."newpad"()
+    unless $P10, rx197_fail
+    rx197_pos = $P10."pos"()
 .annotate 'line', 135
   # rx subrule "blockoid" subtype=capture negate=
-    rx219_cur."!cursor_pos"(rx219_pos)
-    $P10 = rx219_cur."blockoid"()
-    unless $P10, rx219_fail
-    rx219_cur."!mark_push"(0, -1, 0, $P10)
+    rx197_cur."!cursor_pos"(rx197_pos)
+    $P10 = rx197_cur."blockoid"()
+    unless $P10, rx197_fail
+    rx197_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blockoid")
-    rx219_pos = $P10."pos"()
+    rx197_pos = $P10."pos"()
 .annotate 'line', 132
   # rx pass
-    rx219_cur."!cursor_pass"(rx219_pos, "block")
-    rx219_cur."!cursor_debug"("PASS  ", "block", " at pos=", rx219_pos)
-    .return (rx219_cur)
-  rx219_fail:
+    rx197_cur."!cursor_pass"(rx197_pos, "block")
+    rx197_cur."!cursor_debug"("PASS  ", "block", " at pos=", rx197_pos)
+    .return (rx197_cur)
+  rx197_restart:
 .annotate 'line', 4
-    (rx219_rep, rx219_pos, $I10, $P10) = rx219_cur."!mark_fail"(0)
-    lt rx219_pos, -1, rx219_done
-    eq rx219_pos, -1, rx219_fail
+    rx197_cur."!cursor_debug"("NEXT ", "block")
+  rx197_fail:
+    (rx197_rep, rx197_pos, $I10, $P10) = rx197_cur."!mark_fail"(0)
+    lt rx197_pos, -1, rx197_done
+    eq rx197_pos, -1, rx197_fail
     jump $I10
-  rx219_done:
-    rx219_cur."!cursor_fail"()
-    rx219_cur."!cursor_debug"("FAIL  ", "block")
-    .return (rx219_cur)
+  rx197_done:
+    rx197_cur."!cursor_fail"()
+    rx197_cur."!cursor_debug"("FAIL  ", "block")
+    .return (rx197_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__block"  :subid("45_1278500537.15927") :method
+.sub "!PREFIX__block"  :subid("45_1279529226.73787") :method
 .annotate 'line', 4
-    $P221 = self."!PREFIX__!subrule"("panic", "")
-    new $P222, "ResizablePMCArray"
-    push $P222, $P221
-    push $P222, "{"
-    .return ($P222)
+    $P199 = self."!PREFIX__!subrule"("panic", "")
+    new $P200, "ResizablePMCArray"
+    push $P200, $P199
+    push $P200, "{"
+    .return ($P200)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "blockoid"  :subid("46_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "blockoid"  :subid("46_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx226_tgt
-    .local int rx226_pos
-    .local int rx226_off
-    .local int rx226_eos
-    .local int rx226_rep
-    .local pmc rx226_cur
-    (rx226_cur, rx226_pos, rx226_tgt) = self."!cursor_start"()
-    rx226_cur."!cursor_debug"("START ", "blockoid")
-    .lex unicode:"$\x{a2}", rx226_cur
+    .local string rx204_tgt
+    .local int rx204_pos
+    .local int rx204_off
+    .local int rx204_eos
+    .local int rx204_rep
+    .local pmc rx204_cur
+    (rx204_cur, rx204_pos, rx204_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx204_cur
     .local pmc match
     .lex "$/", match
-    length rx226_eos, rx226_tgt
-    gt rx226_pos, rx226_eos, rx226_done
-    set rx226_off, 0
-    lt rx226_pos, 2, rx226_start
-    sub rx226_off, rx226_pos, 1
-    substr rx226_tgt, rx226_tgt, rx226_off
-  rx226_start:
+    length rx204_eos, rx204_tgt
+    gt rx204_pos, rx204_eos, rx204_done
+    set rx204_off, 0
+    lt rx204_pos, 2, rx204_start
+    sub rx204_off, rx204_pos, 1
+    substr rx204_tgt, rx204_tgt, rx204_off
+  rx204_start:
+    eq $I10, 1, rx204_restart
+    rx204_cur."!cursor_debug"("START ", "blockoid")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan230_done
-    goto rxscan230_scan
-  rxscan230_loop:
-    ($P10) = rx226_cur."from"()
+    ne $I10, -1, rxscan208_done
+    goto rxscan208_scan
+  rxscan208_loop:
+    ($P10) = rx204_cur."from"()
     inc $P10
-    set rx226_pos, $P10
-    ge rx226_pos, rx226_eos, rxscan230_done
-  rxscan230_scan:
-    set_addr $I10, rxscan230_loop
-    rx226_cur."!mark_push"(0, rx226_pos, $I10)
-  rxscan230_done:
+    set rx204_pos, $P10
+    ge rx204_pos, rx204_eos, rxscan208_done
+  rxscan208_scan:
+    set_addr $I10, rxscan208_loop
+    rx204_cur."!mark_push"(0, rx204_pos, $I10)
+  rxscan208_done:
 .annotate 'line', 139
   # rx subrule "finishpad" subtype=method negate=
-    rx226_cur."!cursor_pos"(rx226_pos)
-    $P10 = rx226_cur."finishpad"()
-    unless $P10, rx226_fail
-    rx226_pos = $P10."pos"()
+    rx204_cur."!cursor_pos"(rx204_pos)
+    $P10 = rx204_cur."finishpad"()
+    unless $P10, rx204_fail
+    rx204_pos = $P10."pos"()
 .annotate 'line', 140
   # rx literal  "{"
-    add $I11, rx226_pos, 1
-    gt $I11, rx226_eos, rx226_fail
-    sub $I11, rx226_pos, rx226_off
-    substr $S10, rx226_tgt, $I11, 1
-    ne $S10, "{", rx226_fail
-    add rx226_pos, 1
+    add $I11, rx204_pos, 1
+    gt $I11, rx204_eos, rx204_fail
+    sub $I11, rx204_pos, rx204_off
+    substr $S10, rx204_tgt, $I11, 1
+    ne $S10, "{", rx204_fail
+    add rx204_pos, 1
   # rx subrule "statementlist" subtype=capture negate=
-    rx226_cur."!cursor_pos"(rx226_pos)
-    $P10 = rx226_cur."statementlist"()
-    unless $P10, rx226_fail
-    rx226_cur."!mark_push"(0, -1, 0, $P10)
+    rx204_cur."!cursor_pos"(rx204_pos)
+    $P10 = rx204_cur."statementlist"()
+    unless $P10, rx204_fail
+    rx204_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("statementlist")
-    rx226_pos = $P10."pos"()
-  alt231_0:
-    set_addr $I10, alt231_1
-    rx226_cur."!mark_push"(0, rx226_pos, $I10)
+    rx204_pos = $P10."pos"()
+  alt209_0:
+    set_addr $I10, alt209_1
+    rx204_cur."!mark_push"(0, rx204_pos, $I10)
   # rx literal  "}"
-    add $I11, rx226_pos, 1
-    gt $I11, rx226_eos, rx226_fail
-    sub $I11, rx226_pos, rx226_off
-    substr $S10, rx226_tgt, $I11, 1
-    ne $S10, "}", rx226_fail
-    add rx226_pos, 1
-    goto alt231_end
-  alt231_1:
+    add $I11, rx204_pos, 1
+    gt $I11, rx204_eos, rx204_fail
+    sub $I11, rx204_pos, rx204_off
+    substr $S10, rx204_tgt, $I11, 1
+    ne $S10, "}", rx204_fail
+    add rx204_pos, 1
+    goto alt209_end
+  alt209_1:
   # rx subrule "FAILGOAL" subtype=method negate=
-    rx226_cur."!cursor_pos"(rx226_pos)
-    $P10 = rx226_cur."FAILGOAL"("'}'")
-    unless $P10, rx226_fail
-    rx226_pos = $P10."pos"()
-  alt231_end:
+    rx204_cur."!cursor_pos"(rx204_pos)
+    $P10 = rx204_cur."FAILGOAL"("'}'")
+    unless $P10, rx204_fail
+    goto rxsubrule211_pass
+  rxsubrule211_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx204_fail
+  rxsubrule211_pass:
+    set_addr $I10, rxsubrule211_back
+    rx204_cur."!mark_push"(0, rx204_pos, $I10, $P10)
+    rx204_pos = $P10."pos"()
+  alt209_end:
 .annotate 'line', 141
   # rx subrule "ENDSTMT" subtype=zerowidth negate=
-    rx226_cur."!cursor_pos"(rx226_pos)
-    $P10 = rx226_cur."ENDSTMT"()
-    unless $P10, rx226_fail
+    rx204_cur."!cursor_pos"(rx204_pos)
+    $P10 = rx204_cur."ENDSTMT"()
+    unless $P10, rx204_fail
 .annotate 'line', 138
   # rx pass
-    rx226_cur."!cursor_pass"(rx226_pos, "blockoid")
-    rx226_cur."!cursor_debug"("PASS  ", "blockoid", " at pos=", rx226_pos)
-    .return (rx226_cur)
-  rx226_fail:
+    rx204_cur."!cursor_pass"(rx204_pos, "blockoid")
+    rx204_cur."!cursor_debug"("PASS  ", "blockoid", " at pos=", rx204_pos)
+    .return (rx204_cur)
+  rx204_restart:
 .annotate 'line', 4
-    (rx226_rep, rx226_pos, $I10, $P10) = rx226_cur."!mark_fail"(0)
-    lt rx226_pos, -1, rx226_done
-    eq rx226_pos, -1, rx226_fail
+    rx204_cur."!cursor_debug"("NEXT ", "blockoid")
+  rx204_fail:
+    (rx204_rep, rx204_pos, $I10, $P10) = rx204_cur."!mark_fail"(0)
+    lt rx204_pos, -1, rx204_done
+    eq rx204_pos, -1, rx204_fail
     jump $I10
-  rx226_done:
-    rx226_cur."!cursor_fail"()
-    rx226_cur."!cursor_debug"("FAIL  ", "blockoid")
-    .return (rx226_cur)
+  rx204_done:
+    rx204_cur."!cursor_fail"()
+    rx204_cur."!cursor_debug"("FAIL  ", "blockoid")
+    .return (rx204_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__blockoid"  :subid("47_1278500537.15927") :method
+.sub "!PREFIX__blockoid"  :subid("47_1279529226.73787") :method
 .annotate 'line', 4
-    $P228 = self."!PREFIX__!subrule"("finishpad", "")
-    new $P229, "ResizablePMCArray"
-    push $P229, $P228
-    .return ($P229)
+    $P206 = self."!PREFIX__!subrule"("finishpad", "")
+    new $P207, "ResizablePMCArray"
+    push $P207, $P206
+    .return ($P207)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "newpad"  :subid("48_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "newpad"  :subid("48_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx234_tgt
-    .local int rx234_pos
-    .local int rx234_off
-    .local int rx234_eos
-    .local int rx234_rep
-    .local pmc rx234_cur
-    (rx234_cur, rx234_pos, rx234_tgt) = self."!cursor_start"()
-    rx234_cur."!cursor_debug"("START ", "newpad")
-    .lex unicode:"$\x{a2}", rx234_cur
+    .local string rx213_tgt
+    .local int rx213_pos
+    .local int rx213_off
+    .local int rx213_eos
+    .local int rx213_rep
+    .local pmc rx213_cur
+    (rx213_cur, rx213_pos, rx213_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx213_cur
     .local pmc match
     .lex "$/", match
-    length rx234_eos, rx234_tgt
-    gt rx234_pos, rx234_eos, rx234_done
-    set rx234_off, 0
-    lt rx234_pos, 2, rx234_start
-    sub rx234_off, rx234_pos, 1
-    substr rx234_tgt, rx234_tgt, rx234_off
-  rx234_start:
+    length rx213_eos, rx213_tgt
+    gt rx213_pos, rx213_eos, rx213_done
+    set rx213_off, 0
+    lt rx213_pos, 2, rx213_start
+    sub rx213_off, rx213_pos, 1
+    substr rx213_tgt, rx213_tgt, rx213_off
+  rx213_start:
+    eq $I10, 1, rx213_restart
+    rx213_cur."!cursor_debug"("START ", "newpad")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan237_done
-    goto rxscan237_scan
-  rxscan237_loop:
-    ($P10) = rx234_cur."from"()
+    ne $I10, -1, rxscan216_done
+    goto rxscan216_scan
+  rxscan216_loop:
+    ($P10) = rx213_cur."from"()
     inc $P10
-    set rx234_pos, $P10
-    ge rx234_pos, rx234_eos, rxscan237_done
-  rxscan237_scan:
-    set_addr $I10, rxscan237_loop
-    rx234_cur."!mark_push"(0, rx234_pos, $I10)
-  rxscan237_done:
+    set rx213_pos, $P10
+    ge rx213_pos, rx213_eos, rxscan216_done
+  rxscan216_scan:
+    set_addr $I10, rxscan216_loop
+    rx213_cur."!mark_push"(0, rx213_pos, $I10)
+  rxscan216_done:
 .annotate 'line', 144
   # rx pass
-    rx234_cur."!cursor_pass"(rx234_pos, "newpad")
-    rx234_cur."!cursor_debug"("PASS  ", "newpad", " at pos=", rx234_pos)
-    .return (rx234_cur)
-  rx234_fail:
+    rx213_cur."!cursor_pass"(rx213_pos, "newpad")
+    rx213_cur."!cursor_debug"("PASS  ", "newpad", " at pos=", rx213_pos)
+    .return (rx213_cur)
+  rx213_restart:
 .annotate 'line', 4
-    (rx234_rep, rx234_pos, $I10, $P10) = rx234_cur."!mark_fail"(0)
-    lt rx234_pos, -1, rx234_done
-    eq rx234_pos, -1, rx234_fail
+    rx213_cur."!cursor_debug"("NEXT ", "newpad")
+  rx213_fail:
+    (rx213_rep, rx213_pos, $I10, $P10) = rx213_cur."!mark_fail"(0)
+    lt rx213_pos, -1, rx213_done
+    eq rx213_pos, -1, rx213_fail
     jump $I10
-  rx234_done:
-    rx234_cur."!cursor_fail"()
-    rx234_cur."!cursor_debug"("FAIL  ", "newpad")
-    .return (rx234_cur)
+  rx213_done:
+    rx213_cur."!cursor_fail"()
+    rx213_cur."!cursor_debug"("FAIL  ", "newpad")
+    .return (rx213_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__newpad"  :subid("49_1278500537.15927") :method
+.sub "!PREFIX__newpad"  :subid("49_1279529226.73787") :method
 .annotate 'line', 4
-    new $P236, "ResizablePMCArray"
-    push $P236, ""
-    .return ($P236)
+    new $P215, "ResizablePMCArray"
+    push $P215, ""
+    .return ($P215)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "outerctx"  :subid("50_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "outerctx"  :subid("50_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx239_tgt
-    .local int rx239_pos
-    .local int rx239_off
-    .local int rx239_eos
-    .local int rx239_rep
-    .local pmc rx239_cur
-    (rx239_cur, rx239_pos, rx239_tgt) = self."!cursor_start"()
-    rx239_cur."!cursor_debug"("START ", "outerctx")
-    .lex unicode:"$\x{a2}", rx239_cur
-    .local pmc match
-    .lex "$/", match
-    length rx239_eos, rx239_tgt
-    gt rx239_pos, rx239_eos, rx239_done
-    set rx239_off, 0
-    lt rx239_pos, 2, rx239_start
-    sub rx239_off, rx239_pos, 1
-    substr rx239_tgt, rx239_tgt, rx239_off
-  rx239_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan242_done
-    goto rxscan242_scan
-  rxscan242_loop:
-    ($P10) = rx239_cur."from"()
-    inc $P10
-    set rx239_pos, $P10
-    ge rx239_pos, rx239_eos, rxscan242_done
-  rxscan242_scan:
-    set_addr $I10, rxscan242_loop
-    rx239_cur."!mark_push"(0, rx239_pos, $I10)
-  rxscan242_done:
+    .local string rx218_tgt
+    .local int rx218_pos
+    .local int rx218_off
+    .local int rx218_eos
+    .local int rx218_rep
+    .local pmc rx218_cur
+    (rx218_cur, rx218_pos, rx218_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx218_cur
+    .local pmc match
+    .lex "$/", match
+    length rx218_eos, rx218_tgt
+    gt rx218_pos, rx218_eos, rx218_done
+    set rx218_off, 0
+    lt rx218_pos, 2, rx218_start
+    sub rx218_off, rx218_pos, 1
+    substr rx218_tgt, rx218_tgt, rx218_off
+  rx218_start:
+    eq $I10, 1, rx218_restart
+    rx218_cur."!cursor_debug"("START ", "outerctx")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan221_done
+    goto rxscan221_scan
+  rxscan221_loop:
+    ($P10) = rx218_cur."from"()
+    inc $P10
+    set rx218_pos, $P10
+    ge rx218_pos, rx218_eos, rxscan221_done
+  rxscan221_scan:
+    set_addr $I10, rxscan221_loop
+    rx218_cur."!mark_push"(0, rx218_pos, $I10)
+  rxscan221_done:
 .annotate 'line', 145
   # rx pass
-    rx239_cur."!cursor_pass"(rx239_pos, "outerctx")
-    rx239_cur."!cursor_debug"("PASS  ", "outerctx", " at pos=", rx239_pos)
-    .return (rx239_cur)
-  rx239_fail:
+    rx218_cur."!cursor_pass"(rx218_pos, "outerctx")
+    rx218_cur."!cursor_debug"("PASS  ", "outerctx", " at pos=", rx218_pos)
+    .return (rx218_cur)
+  rx218_restart:
 .annotate 'line', 4
-    (rx239_rep, rx239_pos, $I10, $P10) = rx239_cur."!mark_fail"(0)
-    lt rx239_pos, -1, rx239_done
-    eq rx239_pos, -1, rx239_fail
+    rx218_cur."!cursor_debug"("NEXT ", "outerctx")
+  rx218_fail:
+    (rx218_rep, rx218_pos, $I10, $P10) = rx218_cur."!mark_fail"(0)
+    lt rx218_pos, -1, rx218_done
+    eq rx218_pos, -1, rx218_fail
     jump $I10
-  rx239_done:
-    rx239_cur."!cursor_fail"()
-    rx239_cur."!cursor_debug"("FAIL  ", "outerctx")
-    .return (rx239_cur)
+  rx218_done:
+    rx218_cur."!cursor_fail"()
+    rx218_cur."!cursor_debug"("FAIL  ", "outerctx")
+    .return (rx218_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__outerctx"  :subid("51_1278500537.15927") :method
+.sub "!PREFIX__outerctx"  :subid("51_1279529226.73787") :method
 .annotate 'line', 4
-    new $P241, "ResizablePMCArray"
-    push $P241, ""
-    .return ($P241)
+    new $P220, "ResizablePMCArray"
+    push $P220, ""
+    .return ($P220)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "finishpad"  :subid("52_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "finishpad"  :subid("52_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx244_tgt
-    .local int rx244_pos
-    .local int rx244_off
-    .local int rx244_eos
-    .local int rx244_rep
-    .local pmc rx244_cur
-    (rx244_cur, rx244_pos, rx244_tgt) = self."!cursor_start"()
-    rx244_cur."!cursor_debug"("START ", "finishpad")
-    .lex unicode:"$\x{a2}", rx244_cur
+    .local string rx223_tgt
+    .local int rx223_pos
+    .local int rx223_off
+    .local int rx223_eos
+    .local int rx223_rep
+    .local pmc rx223_cur
+    (rx223_cur, rx223_pos, rx223_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx223_cur
     .local pmc match
     .lex "$/", match
-    length rx244_eos, rx244_tgt
-    gt rx244_pos, rx244_eos, rx244_done
-    set rx244_off, 0
-    lt rx244_pos, 2, rx244_start
-    sub rx244_off, rx244_pos, 1
-    substr rx244_tgt, rx244_tgt, rx244_off
-  rx244_start:
+    length rx223_eos, rx223_tgt
+    gt rx223_pos, rx223_eos, rx223_done
+    set rx223_off, 0
+    lt rx223_pos, 2, rx223_start
+    sub rx223_off, rx223_pos, 1
+    substr rx223_tgt, rx223_tgt, rx223_off
+  rx223_start:
+    eq $I10, 1, rx223_restart
+    rx223_cur."!cursor_debug"("START ", "finishpad")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan247_done
-    goto rxscan247_scan
-  rxscan247_loop:
-    ($P10) = rx244_cur."from"()
+    ne $I10, -1, rxscan226_done
+    goto rxscan226_scan
+  rxscan226_loop:
+    ($P10) = rx223_cur."from"()
     inc $P10
-    set rx244_pos, $P10
-    ge rx244_pos, rx244_eos, rxscan247_done
-  rxscan247_scan:
-    set_addr $I10, rxscan247_loop
-    rx244_cur."!mark_push"(0, rx244_pos, $I10)
-  rxscan247_done:
+    set rx223_pos, $P10
+    ge rx223_pos, rx223_eos, rxscan226_done
+  rxscan226_scan:
+    set_addr $I10, rxscan226_loop
+    rx223_cur."!mark_push"(0, rx223_pos, $I10)
+  rxscan226_done:
 .annotate 'line', 146
   # rx pass
-    rx244_cur."!cursor_pass"(rx244_pos, "finishpad")
-    rx244_cur."!cursor_debug"("PASS  ", "finishpad", " at pos=", rx244_pos)
-    .return (rx244_cur)
-  rx244_fail:
+    rx223_cur."!cursor_pass"(rx223_pos, "finishpad")
+    rx223_cur."!cursor_debug"("PASS  ", "finishpad", " at pos=", rx223_pos)
+    .return (rx223_cur)
+  rx223_restart:
 .annotate 'line', 4
-    (rx244_rep, rx244_pos, $I10, $P10) = rx244_cur."!mark_fail"(0)
-    lt rx244_pos, -1, rx244_done
-    eq rx244_pos, -1, rx244_fail
+    rx223_cur."!cursor_debug"("NEXT ", "finishpad")
+  rx223_fail:
+    (rx223_rep, rx223_pos, $I10, $P10) = rx223_cur."!mark_fail"(0)
+    lt rx223_pos, -1, rx223_done
+    eq rx223_pos, -1, rx223_fail
     jump $I10
-  rx244_done:
-    rx244_cur."!cursor_fail"()
-    rx244_cur."!cursor_debug"("FAIL  ", "finishpad")
-    .return (rx244_cur)
+  rx223_done:
+    rx223_cur."!cursor_fail"()
+    rx223_cur."!cursor_debug"("FAIL  ", "finishpad")
+    .return (rx223_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__finishpad"  :subid("53_1278500537.15927") :method
+.sub "!PREFIX__finishpad"  :subid("53_1279529226.73787") :method
 .annotate 'line', 4
-    new $P246, "ResizablePMCArray"
-    push $P246, ""
-    .return ($P246)
+    new $P225, "ResizablePMCArray"
+    push $P225, ""
+    .return ($P225)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "terminator"  :subid("54_1278500537.15927") :method
+.sub "terminator"  :subid("54_1279529226.73787") :method
 .annotate 'line', 148
-    $P249 = self."!protoregex"("terminator")
-    .return ($P249)
+    $P228 = self."!protoregex"("terminator")
+    .return ($P228)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__terminator"  :subid("55_1278500537.15927") :method
+.sub "!PREFIX__terminator"  :subid("55_1279529226.73787") :method
 .annotate 'line', 148
-    $P251 = self."!PREFIX__!protoregex"("terminator")
-    .return ($P251)
+    $P230 = self."!PREFIX__!protoregex"("terminator")
+    .return ($P230)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "terminator:sym<;>"  :subid("56_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "terminator:sym<;>"  :subid("56_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx253_tgt
-    .local int rx253_pos
-    .local int rx253_off
-    .local int rx253_eos
-    .local int rx253_rep
-    .local pmc rx253_cur
-    (rx253_cur, rx253_pos, rx253_tgt) = self."!cursor_start"()
-    rx253_cur."!cursor_debug"("START ", "terminator:sym<;>")
-    .lex unicode:"$\x{a2}", rx253_cur
-    .local pmc match
-    .lex "$/", match
-    length rx253_eos, rx253_tgt
-    gt rx253_pos, rx253_eos, rx253_done
-    set rx253_off, 0
-    lt rx253_pos, 2, rx253_start
-    sub rx253_off, rx253_pos, 1
-    substr rx253_tgt, rx253_tgt, rx253_off
-  rx253_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan256_done
-    goto rxscan256_scan
-  rxscan256_loop:
-    ($P10) = rx253_cur."from"()
-    inc $P10
-    set rx253_pos, $P10
-    ge rx253_pos, rx253_eos, rxscan256_done
-  rxscan256_scan:
-    set_addr $I10, rxscan256_loop
-    rx253_cur."!mark_push"(0, rx253_pos, $I10)
-  rxscan256_done:
+    .local string rx232_tgt
+    .local int rx232_pos
+    .local int rx232_off
+    .local int rx232_eos
+    .local int rx232_rep
+    .local pmc rx232_cur
+    (rx232_cur, rx232_pos, rx232_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx232_cur
+    .local pmc match
+    .lex "$/", match
+    length rx232_eos, rx232_tgt
+    gt rx232_pos, rx232_eos, rx232_done
+    set rx232_off, 0
+    lt rx232_pos, 2, rx232_start
+    sub rx232_off, rx232_pos, 1
+    substr rx232_tgt, rx232_tgt, rx232_off
+  rx232_start:
+    eq $I10, 1, rx232_restart
+    rx232_cur."!cursor_debug"("START ", "terminator:sym<;>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan235_done
+    goto rxscan235_scan
+  rxscan235_loop:
+    ($P10) = rx232_cur."from"()
+    inc $P10
+    set rx232_pos, $P10
+    ge rx232_pos, rx232_eos, rxscan235_done
+  rxscan235_scan:
+    set_addr $I10, rxscan235_loop
+    rx232_cur."!mark_push"(0, rx232_pos, $I10)
+  rxscan235_done:
 .annotate 'line', 150
   # rx enumcharlist negate=0 zerowidth
-    ge rx253_pos, rx253_eos, rx253_fail
-    sub $I10, rx253_pos, rx253_off
-    substr $S10, rx253_tgt, $I10, 1
+    ge rx232_pos, rx232_eos, rx232_fail
+    sub $I10, rx232_pos, rx232_off
+    substr $S10, rx232_tgt, $I10, 1
     index $I11, ";", $S10
-    lt $I11, 0, rx253_fail
+    lt $I11, 0, rx232_fail
   # rx pass
-    rx253_cur."!cursor_pass"(rx253_pos, "terminator:sym<;>")
-    rx253_cur."!cursor_debug"("PASS  ", "terminator:sym<;>", " at pos=", rx253_pos)
-    .return (rx253_cur)
-  rx253_fail:
+    rx232_cur."!cursor_pass"(rx232_pos, "terminator:sym<;>")
+    rx232_cur."!cursor_debug"("PASS  ", "terminator:sym<;>", " at pos=", rx232_pos)
+    .return (rx232_cur)
+  rx232_restart:
 .annotate 'line', 4
-    (rx253_rep, rx253_pos, $I10, $P10) = rx253_cur."!mark_fail"(0)
-    lt rx253_pos, -1, rx253_done
-    eq rx253_pos, -1, rx253_fail
+    rx232_cur."!cursor_debug"("NEXT ", "terminator:sym<;>")
+  rx232_fail:
+    (rx232_rep, rx232_pos, $I10, $P10) = rx232_cur."!mark_fail"(0)
+    lt rx232_pos, -1, rx232_done
+    eq rx232_pos, -1, rx232_fail
     jump $I10
-  rx253_done:
-    rx253_cur."!cursor_fail"()
-    rx253_cur."!cursor_debug"("FAIL  ", "terminator:sym<;>")
-    .return (rx253_cur)
+  rx232_done:
+    rx232_cur."!cursor_fail"()
+    rx232_cur."!cursor_debug"("FAIL  ", "terminator:sym<;>")
+    .return (rx232_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__terminator:sym<;>"  :subid("57_1278500537.15927") :method
+.sub "!PREFIX__terminator:sym<;>"  :subid("57_1279529226.73787") :method
 .annotate 'line', 4
-    new $P255, "ResizablePMCArray"
-    push $P255, ";"
-    .return ($P255)
+    new $P234, "ResizablePMCArray"
+    push $P234, ";"
+    .return ($P234)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "terminator:sym<}>"  :subid("58_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "terminator:sym<}>"  :subid("58_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx258_tgt
-    .local int rx258_pos
-    .local int rx258_off
-    .local int rx258_eos
-    .local int rx258_rep
-    .local pmc rx258_cur
-    (rx258_cur, rx258_pos, rx258_tgt) = self."!cursor_start"()
-    rx258_cur."!cursor_debug"("START ", "terminator:sym<}>")
-    .lex unicode:"$\x{a2}", rx258_cur
+    .local string rx237_tgt
+    .local int rx237_pos
+    .local int rx237_off
+    .local int rx237_eos
+    .local int rx237_rep
+    .local pmc rx237_cur
+    (rx237_cur, rx237_pos, rx237_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx237_cur
     .local pmc match
     .lex "$/", match
-    length rx258_eos, rx258_tgt
-    gt rx258_pos, rx258_eos, rx258_done
-    set rx258_off, 0
-    lt rx258_pos, 2, rx258_start
-    sub rx258_off, rx258_pos, 1
-    substr rx258_tgt, rx258_tgt, rx258_off
-  rx258_start:
+    length rx237_eos, rx237_tgt
+    gt rx237_pos, rx237_eos, rx237_done
+    set rx237_off, 0
+    lt rx237_pos, 2, rx237_start
+    sub rx237_off, rx237_pos, 1
+    substr rx237_tgt, rx237_tgt, rx237_off
+  rx237_start:
+    eq $I10, 1, rx237_restart
+    rx237_cur."!cursor_debug"("START ", "terminator:sym<}>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan261_done
-    goto rxscan261_scan
-  rxscan261_loop:
-    ($P10) = rx258_cur."from"()
+    ne $I10, -1, rxscan240_done
+    goto rxscan240_scan
+  rxscan240_loop:
+    ($P10) = rx237_cur."from"()
     inc $P10
-    set rx258_pos, $P10
-    ge rx258_pos, rx258_eos, rxscan261_done
-  rxscan261_scan:
-    set_addr $I10, rxscan261_loop
-    rx258_cur."!mark_push"(0, rx258_pos, $I10)
-  rxscan261_done:
+    set rx237_pos, $P10
+    ge rx237_pos, rx237_eos, rxscan240_done
+  rxscan240_scan:
+    set_addr $I10, rxscan240_loop
+    rx237_cur."!mark_push"(0, rx237_pos, $I10)
+  rxscan240_done:
 .annotate 'line', 151
   # rx enumcharlist negate=0 zerowidth
-    ge rx258_pos, rx258_eos, rx258_fail
-    sub $I10, rx258_pos, rx258_off
-    substr $S10, rx258_tgt, $I10, 1
+    ge rx237_pos, rx237_eos, rx237_fail
+    sub $I10, rx237_pos, rx237_off
+    substr $S10, rx237_tgt, $I10, 1
     index $I11, "}", $S10
-    lt $I11, 0, rx258_fail
+    lt $I11, 0, rx237_fail
   # rx pass
-    rx258_cur."!cursor_pass"(rx258_pos, "terminator:sym<}>")
-    rx258_cur."!cursor_debug"("PASS  ", "terminator:sym<}>", " at pos=", rx258_pos)
-    .return (rx258_cur)
-  rx258_fail:
+    rx237_cur."!cursor_pass"(rx237_pos, "terminator:sym<}>")
+    rx237_cur."!cursor_debug"("PASS  ", "terminator:sym<}>", " at pos=", rx237_pos)
+    .return (rx237_cur)
+  rx237_restart:
 .annotate 'line', 4
-    (rx258_rep, rx258_pos, $I10, $P10) = rx258_cur."!mark_fail"(0)
-    lt rx258_pos, -1, rx258_done
-    eq rx258_pos, -1, rx258_fail
+    rx237_cur."!cursor_debug"("NEXT ", "terminator:sym<}>")
+  rx237_fail:
+    (rx237_rep, rx237_pos, $I10, $P10) = rx237_cur."!mark_fail"(0)
+    lt rx237_pos, -1, rx237_done
+    eq rx237_pos, -1, rx237_fail
     jump $I10
-  rx258_done:
-    rx258_cur."!cursor_fail"()
-    rx258_cur."!cursor_debug"("FAIL  ", "terminator:sym<}>")
-    .return (rx258_cur)
+  rx237_done:
+    rx237_cur."!cursor_fail"()
+    rx237_cur."!cursor_debug"("FAIL  ", "terminator:sym<}>")
+    .return (rx237_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__terminator:sym<}>"  :subid("59_1278500537.15927") :method
+.sub "!PREFIX__terminator:sym<}>"  :subid("59_1279529226.73787") :method
 .annotate 'line', 4
-    new $P260, "ResizablePMCArray"
-    push $P260, "}"
-    .return ($P260)
+    new $P239, "ResizablePMCArray"
+    push $P239, "}"
+    .return ($P239)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control"  :subid("60_1278500537.15927") :method
+.sub "statement_control"  :subid("60_1279529226.73787") :method
 .annotate 'line', 155
-    $P263 = self."!protoregex"("statement_control")
-    .return ($P263)
+    $P242 = self."!protoregex"("statement_control")
+    .return ($P242)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control"  :subid("61_1278500537.15927") :method
+.sub "!PREFIX__statement_control"  :subid("61_1279529226.73787") :method
 .annotate 'line', 155
-    $P265 = self."!PREFIX__!protoregex"("statement_control")
-    .return ($P265)
+    $P244 = self."!PREFIX__!protoregex"("statement_control")
+    .return ($P244)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<if>"  :subid("62_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_control:sym<if>"  :subid("62_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx267_tgt
-    .local int rx267_pos
-    .local int rx267_off
-    .local int rx267_eos
-    .local int rx267_rep
-    .local pmc rx267_cur
-    (rx267_cur, rx267_pos, rx267_tgt) = self."!cursor_start"()
-    rx267_cur."!cursor_debug"("START ", "statement_control:sym<if>")
-    rx267_cur."!cursor_caparray"("else", "xblock")
-    .lex unicode:"$\x{a2}", rx267_cur
-    .local pmc match
-    .lex "$/", match
-    length rx267_eos, rx267_tgt
-    gt rx267_pos, rx267_eos, rx267_done
-    set rx267_off, 0
-    lt rx267_pos, 2, rx267_start
-    sub rx267_off, rx267_pos, 1
-    substr rx267_tgt, rx267_tgt, rx267_off
-  rx267_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan270_done
-    goto rxscan270_scan
-  rxscan270_loop:
-    ($P10) = rx267_cur."from"()
-    inc $P10
-    set rx267_pos, $P10
-    ge rx267_pos, rx267_eos, rxscan270_done
-  rxscan270_scan:
-    set_addr $I10, rxscan270_loop
-    rx267_cur."!mark_push"(0, rx267_pos, $I10)
-  rxscan270_done:
+    .local string rx246_tgt
+    .local int rx246_pos
+    .local int rx246_off
+    .local int rx246_eos
+    .local int rx246_rep
+    .local pmc rx246_cur
+    (rx246_cur, rx246_pos, rx246_tgt, $I10) = self."!cursor_start"()
+    rx246_cur."!cursor_caparray"("else", "xblock")
+    .lex unicode:"$\x{a2}", rx246_cur
+    .local pmc match
+    .lex "$/", match
+    length rx246_eos, rx246_tgt
+    gt rx246_pos, rx246_eos, rx246_done
+    set rx246_off, 0
+    lt rx246_pos, 2, rx246_start
+    sub rx246_off, rx246_pos, 1
+    substr rx246_tgt, rx246_tgt, rx246_off
+  rx246_start:
+    eq $I10, 1, rx246_restart
+    rx246_cur."!cursor_debug"("START ", "statement_control:sym<if>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan249_done
+    goto rxscan249_scan
+  rxscan249_loop:
+    ($P10) = rx246_cur."from"()
+    inc $P10
+    set rx246_pos, $P10
+    ge rx246_pos, rx246_eos, rxscan249_done
+  rxscan249_scan:
+    set_addr $I10, rxscan249_loop
+    rx246_cur."!mark_push"(0, rx246_pos, $I10)
+  rxscan249_done:
 .annotate 'line', 158
   # rx subcapture "sym"
-    set_addr $I10, rxcap_271_fail
-    rx267_cur."!mark_push"(0, rx267_pos, $I10)
+    set_addr $I10, rxcap_250_fail
+    rx246_cur."!mark_push"(0, rx246_pos, $I10)
   # rx literal  "if"
-    add $I11, rx267_pos, 2
-    gt $I11, rx267_eos, rx267_fail
-    sub $I11, rx267_pos, rx267_off
-    substr $S10, rx267_tgt, $I11, 2
-    ne $S10, "if", rx267_fail
-    add rx267_pos, 2
-    set_addr $I10, rxcap_271_fail
-    ($I12, $I11) = rx267_cur."!mark_peek"($I10)
-    rx267_cur."!cursor_pos"($I11)
-    ($P10) = rx267_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx267_pos, "")
-    rx267_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx246_pos, 2
+    gt $I11, rx246_eos, rx246_fail
+    sub $I11, rx246_pos, rx246_off
+    substr $S10, rx246_tgt, $I11, 2
+    ne $S10, "if", rx246_fail
+    add rx246_pos, 2
+    set_addr $I10, rxcap_250_fail
+    ($I12, $I11) = rx246_cur."!mark_peek"($I10)
+    rx246_cur."!cursor_pos"($I11)
+    ($P10) = rx246_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx246_pos, "")
+    rx246_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_271_done
-  rxcap_271_fail:
-    goto rx267_fail
-  rxcap_271_done:
+    goto rxcap_250_done
+  rxcap_250_fail:
+    goto rx246_fail
+  rxcap_250_done:
   # rx charclass s
-    ge rx267_pos, rx267_eos, rx267_fail
-    sub $I10, rx267_pos, rx267_off
-    is_cclass $I11, 32, rx267_tgt, $I10
-    unless $I11, rx267_fail
-    inc rx267_pos
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+    ge rx246_pos, rx246_eos, rx246_fail
+    sub $I10, rx246_pos, rx246_off
+    is_cclass $I11, 32, rx246_tgt, $I10
+    unless $I11, rx246_fail
+    inc rx246_pos
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
 .annotate 'line', 159
   # rx subrule "xblock" subtype=capture negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."xblock"()
-    unless $P10, rx267_fail
-    rx267_cur."!mark_push"(0, -1, 0, $P10)
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."xblock"()
+    unless $P10, rx246_fail
+    rx246_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("xblock")
-    rx267_pos = $P10."pos"()
+    rx246_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
 .annotate 'line', 160
-  # rx rxquantr274 ** 0..*
-    set_addr $I278, rxquantr274_done
-    rx267_cur."!mark_push"(0, rx267_pos, $I278)
-  rxquantr274_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+  # rx rxquantr253 ** 0..*
+    set_addr $I10, rxquantr253_done
+    rx246_cur."!mark_push"(0, rx246_pos, $I10)
+  rxquantr253_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
   # rx literal  "elsif"
-    add $I11, rx267_pos, 5
-    gt $I11, rx267_eos, rx267_fail
-    sub $I11, rx267_pos, rx267_off
-    substr $S10, rx267_tgt, $I11, 5
-    ne $S10, "elsif", rx267_fail
-    add rx267_pos, 5
+    add $I11, rx246_pos, 5
+    gt $I11, rx246_eos, rx246_fail
+    sub $I11, rx246_pos, rx246_off
+    substr $S10, rx246_tgt, $I11, 5
+    ne $S10, "elsif", rx246_fail
+    add rx246_pos, 5
   # rx charclass s
-    ge rx267_pos, rx267_eos, rx267_fail
-    sub $I10, rx267_pos, rx267_off
-    is_cclass $I11, 32, rx267_tgt, $I10
-    unless $I11, rx267_fail
-    inc rx267_pos
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+    ge rx246_pos, rx246_eos, rx246_fail
+    sub $I10, rx246_pos, rx246_off
+    is_cclass $I11, 32, rx246_tgt, $I10
+    unless $I11, rx246_fail
+    inc rx246_pos
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
   # rx subrule "xblock" subtype=capture negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."xblock"()
-    unless $P10, rx267_fail
-    rx267_cur."!mark_push"(0, -1, 0, $P10)
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."xblock"()
+    unless $P10, rx246_fail
+    rx246_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("xblock")
-    rx267_pos = $P10."pos"()
+    rx246_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
-    (rx267_rep) = rx267_cur."!mark_commit"($I278)
-    rx267_cur."!mark_push"(rx267_rep, rx267_pos, $I278)
-    goto rxquantr274_loop
-  rxquantr274_done:
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
+    set_addr $I10, rxquantr253_done
+    (rx246_rep) = rx246_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr253_done
+    rx246_cur."!mark_push"(rx246_rep, rx246_pos, $I10)
+    goto rxquantr253_loop
+  rxquantr253_done:
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
 .annotate 'line', 161
-  # rx rxquantr280 ** 0..1
-    set_addr $I284, rxquantr280_done
-    rx267_cur."!mark_push"(0, rx267_pos, $I284)
-  rxquantr280_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+  # rx rxquantr258 ** 0..1
+    set_addr $I10, rxquantr258_done
+    rx246_cur."!mark_push"(0, rx246_pos, $I10)
+  rxquantr258_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
   # rx literal  "else"
-    add $I11, rx267_pos, 4
-    gt $I11, rx267_eos, rx267_fail
-    sub $I11, rx267_pos, rx267_off
-    substr $S10, rx267_tgt, $I11, 4
-    ne $S10, "else", rx267_fail
-    add rx267_pos, 4
+    add $I11, rx246_pos, 4
+    gt $I11, rx246_eos, rx246_fail
+    sub $I11, rx246_pos, rx246_off
+    substr $S10, rx246_tgt, $I11, 4
+    ne $S10, "else", rx246_fail
+    add rx246_pos, 4
   # rx charclass s
-    ge rx267_pos, rx267_eos, rx267_fail
-    sub $I10, rx267_pos, rx267_off
-    is_cclass $I11, 32, rx267_tgt, $I10
-    unless $I11, rx267_fail
-    inc rx267_pos
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+    ge rx246_pos, rx246_eos, rx246_fail
+    sub $I10, rx246_pos, rx246_off
+    is_cclass $I11, 32, rx246_tgt, $I10
+    unless $I11, rx246_fail
+    inc rx246_pos
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
   # rx subrule "pblock" subtype=capture negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."pblock"()
-    unless $P10, rx267_fail
-    rx267_cur."!mark_push"(0, -1, 0, $P10)
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."pblock"()
+    unless $P10, rx246_fail
+    rx246_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("else")
-    rx267_pos = $P10."pos"()
+    rx246_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
-    (rx267_rep) = rx267_cur."!mark_commit"($I284)
-  rxquantr280_done:
-  # rx subrule "ws" subtype=method negate=
-    rx267_cur."!cursor_pos"(rx267_pos)
-    $P10 = rx267_cur."ws"()
-    unless $P10, rx267_fail
-    rx267_pos = $P10."pos"()
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
+    set_addr $I10, rxquantr258_done
+    (rx246_rep) = rx246_cur."!mark_commit"($I10)
+  rxquantr258_done:
+  # rx subrule "ws" subtype=method negate=
+    rx246_cur."!cursor_pos"(rx246_pos)
+    $P10 = rx246_cur."ws"()
+    unless $P10, rx246_fail
+    rx246_pos = $P10."pos"()
 .annotate 'line', 157
   # rx pass
-    rx267_cur."!cursor_pass"(rx267_pos, "statement_control:sym<if>")
-    rx267_cur."!cursor_debug"("PASS  ", "statement_control:sym<if>", " at pos=", rx267_pos)
-    .return (rx267_cur)
-  rx267_fail:
+    rx246_cur."!cursor_pass"(rx246_pos, "statement_control:sym<if>")
+    rx246_cur."!cursor_debug"("PASS  ", "statement_control:sym<if>", " at pos=", rx246_pos)
+    .return (rx246_cur)
+  rx246_restart:
 .annotate 'line', 4
-    (rx267_rep, rx267_pos, $I10, $P10) = rx267_cur."!mark_fail"(0)
-    lt rx267_pos, -1, rx267_done
-    eq rx267_pos, -1, rx267_fail
+    rx246_cur."!cursor_debug"("NEXT ", "statement_control:sym<if>")
+  rx246_fail:
+    (rx246_rep, rx246_pos, $I10, $P10) = rx246_cur."!mark_fail"(0)
+    lt rx246_pos, -1, rx246_done
+    eq rx246_pos, -1, rx246_fail
     jump $I10
-  rx267_done:
-    rx267_cur."!cursor_fail"()
-    rx267_cur."!cursor_debug"("FAIL  ", "statement_control:sym<if>")
-    .return (rx267_cur)
+  rx246_done:
+    rx246_cur."!cursor_fail"()
+    rx246_cur."!cursor_debug"("FAIL  ", "statement_control:sym<if>")
+    .return (rx246_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<if>"  :subid("63_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<if>"  :subid("63_1279529226.73787") :method
 .annotate 'line', 4
-    new $P269, "ResizablePMCArray"
-    push $P269, "if"
-    .return ($P269)
+    new $P248, "ResizablePMCArray"
+    push $P248, "if"
+    .return ($P248)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<unless>"  :subid("64_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_control:sym<unless>"  :subid("64_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .const 'Sub' $P297 = "66_1278500537.15927" 
-    capture_lex $P297
-    .local string rx287_tgt
-    .local int rx287_pos
-    .local int rx287_off
-    .local int rx287_eos
-    .local int rx287_rep
-    .local pmc rx287_cur
-    (rx287_cur, rx287_pos, rx287_tgt) = self."!cursor_start"()
-    rx287_cur."!cursor_debug"("START ", "statement_control:sym<unless>")
-    .lex unicode:"$\x{a2}", rx287_cur
+    .const 'Sub' $P274 = "66_1279529226.73787" 
+    capture_lex $P274
+    .local string rx264_tgt
+    .local int rx264_pos
+    .local int rx264_off
+    .local int rx264_eos
+    .local int rx264_rep
+    .local pmc rx264_cur
+    (rx264_cur, rx264_pos, rx264_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx264_cur
     .local pmc match
     .lex "$/", match
-    length rx287_eos, rx287_tgt
-    gt rx287_pos, rx287_eos, rx287_done
-    set rx287_off, 0
-    lt rx287_pos, 2, rx287_start
-    sub rx287_off, rx287_pos, 1
-    substr rx287_tgt, rx287_tgt, rx287_off
-  rx287_start:
+    length rx264_eos, rx264_tgt
+    gt rx264_pos, rx264_eos, rx264_done
+    set rx264_off, 0
+    lt rx264_pos, 2, rx264_start
+    sub rx264_off, rx264_pos, 1
+    substr rx264_tgt, rx264_tgt, rx264_off
+  rx264_start:
+    eq $I10, 1, rx264_restart
+    rx264_cur."!cursor_debug"("START ", "statement_control:sym<unless>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan290_done
-    goto rxscan290_scan
-  rxscan290_loop:
-    ($P10) = rx287_cur."from"()
+    ne $I10, -1, rxscan267_done
+    goto rxscan267_scan
+  rxscan267_loop:
+    ($P10) = rx264_cur."from"()
     inc $P10
-    set rx287_pos, $P10
-    ge rx287_pos, rx287_eos, rxscan290_done
-  rxscan290_scan:
-    set_addr $I10, rxscan290_loop
-    rx287_cur."!mark_push"(0, rx287_pos, $I10)
-  rxscan290_done:
+    set rx264_pos, $P10
+    ge rx264_pos, rx264_eos, rxscan267_done
+  rxscan267_scan:
+    set_addr $I10, rxscan267_loop
+    rx264_cur."!mark_push"(0, rx264_pos, $I10)
+  rxscan267_done:
 .annotate 'line', 165
   # rx subcapture "sym"
-    set_addr $I10, rxcap_291_fail
-    rx287_cur."!mark_push"(0, rx287_pos, $I10)
+    set_addr $I10, rxcap_268_fail
+    rx264_cur."!mark_push"(0, rx264_pos, $I10)
   # rx literal  "unless"
-    add $I11, rx287_pos, 6
-    gt $I11, rx287_eos, rx287_fail
-    sub $I11, rx287_pos, rx287_off
-    substr $S10, rx287_tgt, $I11, 6
-    ne $S10, "unless", rx287_fail
-    add rx287_pos, 6
-    set_addr $I10, rxcap_291_fail
-    ($I12, $I11) = rx287_cur."!mark_peek"($I10)
-    rx287_cur."!cursor_pos"($I11)
-    ($P10) = rx287_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx287_pos, "")
-    rx287_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx264_pos, 6
+    gt $I11, rx264_eos, rx264_fail
+    sub $I11, rx264_pos, rx264_off
+    substr $S10, rx264_tgt, $I11, 6
+    ne $S10, "unless", rx264_fail
+    add rx264_pos, 6
+    set_addr $I10, rxcap_268_fail
+    ($I12, $I11) = rx264_cur."!mark_peek"($I10)
+    rx264_cur."!cursor_pos"($I11)
+    ($P10) = rx264_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx264_pos, "")
+    rx264_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_291_done
-  rxcap_291_fail:
-    goto rx287_fail
-  rxcap_291_done:
+    goto rxcap_268_done
+  rxcap_268_fail:
+    goto rx264_fail
+  rxcap_268_done:
   # rx charclass s
-    ge rx287_pos, rx287_eos, rx287_fail
-    sub $I10, rx287_pos, rx287_off
-    is_cclass $I11, 32, rx287_tgt, $I10
-    unless $I11, rx287_fail
-    inc rx287_pos
-  # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
+    ge rx264_pos, rx264_eos, rx264_fail
+    sub $I10, rx264_pos, rx264_off
+    is_cclass $I11, 32, rx264_tgt, $I10
+    unless $I11, rx264_fail
+    inc rx264_pos
+  # rx subrule "ws" subtype=method negate=
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
 .annotate 'line', 166
   # rx subrule "xblock" subtype=capture negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."xblock"()
-    unless $P10, rx287_fail
-    rx287_cur."!mark_push"(0, -1, 0, $P10)
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."xblock"()
+    unless $P10, rx264_fail
+    rx264_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("xblock")
-    rx287_pos = $P10."pos"()
+    rx264_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
-  alt294_0:
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
+  alt271_0:
 .annotate 'line', 167
-    set_addr $I10, alt294_1
-    rx287_cur."!mark_push"(0, rx287_pos, $I10)
+    set_addr $I10, alt271_1
+    rx264_cur."!mark_push"(0, rx264_pos, $I10)
   # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
   # rx subrule "before" subtype=zerowidth negate=1
-    rx287_cur."!cursor_pos"(rx287_pos)
-    .const 'Sub' $P297 = "66_1278500537.15927" 
-    capture_lex $P297
-    $P10 = rx287_cur."before"($P297)
-    if $P10, rx287_fail
-  # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
-    goto alt294_end
-  alt294_1:
-  # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
+    rx264_cur."!cursor_pos"(rx264_pos)
+    .const 'Sub' $P274 = "66_1279529226.73787" 
+    capture_lex $P274
+    $P10 = rx264_cur."before"($P274)
+    if $P10, rx264_fail
+  # rx subrule "ws" subtype=method negate=
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
+    goto alt271_end
+  alt271_1:
+  # rx subrule "ws" subtype=method negate=
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
   # rx subrule "panic" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."panic"("unless does not take \"else\", please rewrite using \"if\"")
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
-  alt294_end:
-  # rx subrule "ws" subtype=method negate=
-    rx287_cur."!cursor_pos"(rx287_pos)
-    $P10 = rx287_cur."ws"()
-    unless $P10, rx287_fail
-    rx287_pos = $P10."pos"()
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."panic"("unless does not take \"else\", please rewrite using \"if\"")
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
+  alt271_end:
+  # rx subrule "ws" subtype=method negate=
+    rx264_cur."!cursor_pos"(rx264_pos)
+    $P10 = rx264_cur."ws"()
+    unless $P10, rx264_fail
+    rx264_pos = $P10."pos"()
 .annotate 'line', 164
   # rx pass
-    rx287_cur."!cursor_pass"(rx287_pos, "statement_control:sym<unless>")
-    rx287_cur."!cursor_debug"("PASS  ", "statement_control:sym<unless>", " at pos=", rx287_pos)
-    .return (rx287_cur)
-  rx287_fail:
+    rx264_cur."!cursor_pass"(rx264_pos, "statement_control:sym<unless>")
+    rx264_cur."!cursor_debug"("PASS  ", "statement_control:sym<unless>", " at pos=", rx264_pos)
+    .return (rx264_cur)
+  rx264_restart:
 .annotate 'line', 4
-    (rx287_rep, rx287_pos, $I10, $P10) = rx287_cur."!mark_fail"(0)
-    lt rx287_pos, -1, rx287_done
-    eq rx287_pos, -1, rx287_fail
+    rx264_cur."!cursor_debug"("NEXT ", "statement_control:sym<unless>")
+  rx264_fail:
+    (rx264_rep, rx264_pos, $I10, $P10) = rx264_cur."!mark_fail"(0)
+    lt rx264_pos, -1, rx264_done
+    eq rx264_pos, -1, rx264_fail
     jump $I10
-  rx287_done:
-    rx287_cur."!cursor_fail"()
-    rx287_cur."!cursor_debug"("FAIL  ", "statement_control:sym<unless>")
-    .return (rx287_cur)
+  rx264_done:
+    rx264_cur."!cursor_fail"()
+    rx264_cur."!cursor_debug"("FAIL  ", "statement_control:sym<unless>")
+    .return (rx264_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<unless>"  :subid("65_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<unless>"  :subid("65_1279529226.73787") :method
 .annotate 'line', 4
-    new $P289, "ResizablePMCArray"
-    push $P289, "unless"
-    .return ($P289)
+    new $P266, "ResizablePMCArray"
+    push $P266, "unless"
+    .return ($P266)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block296"  :anon :subid("66_1278500537.15927") :method :outer("64_1278500537.15927")
+.sub "_block273"  :anon :subid("66_1279529226.73787") :method :outer("64_1279529226.73787")
 .annotate 'line', 167
-    .local string rx298_tgt
-    .local int rx298_pos
-    .local int rx298_off
-    .local int rx298_eos
-    .local int rx298_rep
-    .local pmc rx298_cur
-    (rx298_cur, rx298_pos, rx298_tgt) = self."!cursor_start"()
-    rx298_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx298_cur
-    .local pmc match
-    .lex "$/", match
-    length rx298_eos, rx298_tgt
-    gt rx298_pos, rx298_eos, rx298_done
-    set rx298_off, 0
-    lt rx298_pos, 2, rx298_start
-    sub rx298_off, rx298_pos, 1
-    substr rx298_tgt, rx298_tgt, rx298_off
-  rx298_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan299_done
-    goto rxscan299_scan
-  rxscan299_loop:
-    ($P10) = rx298_cur."from"()
-    inc $P10
-    set rx298_pos, $P10
-    ge rx298_pos, rx298_eos, rxscan299_done
-  rxscan299_scan:
-    set_addr $I10, rxscan299_loop
-    rx298_cur."!mark_push"(0, rx298_pos, $I10)
-  rxscan299_done:
+    .local string rx275_tgt
+    .local int rx275_pos
+    .local int rx275_off
+    .local int rx275_eos
+    .local int rx275_rep
+    .local pmc rx275_cur
+    (rx275_cur, rx275_pos, rx275_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx275_cur
+    .local pmc match
+    .lex "$/", match
+    length rx275_eos, rx275_tgt
+    gt rx275_pos, rx275_eos, rx275_done
+    set rx275_off, 0
+    lt rx275_pos, 2, rx275_start
+    sub rx275_off, rx275_pos, 1
+    substr rx275_tgt, rx275_tgt, rx275_off
+  rx275_start:
+    eq $I10, 1, rx275_restart
+    rx275_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan276_done
+    goto rxscan276_scan
+  rxscan276_loop:
+    ($P10) = rx275_cur."from"()
+    inc $P10
+    set rx275_pos, $P10
+    ge rx275_pos, rx275_eos, rxscan276_done
+  rxscan276_scan:
+    set_addr $I10, rxscan276_loop
+    rx275_cur."!mark_push"(0, rx275_pos, $I10)
+  rxscan276_done:
   # rx literal  "else"
-    add $I11, rx298_pos, 4
-    gt $I11, rx298_eos, rx298_fail
-    sub $I11, rx298_pos, rx298_off
-    substr $S10, rx298_tgt, $I11, 4
-    ne $S10, "else", rx298_fail
-    add rx298_pos, 4
-  # rx pass
-    rx298_cur."!cursor_pass"(rx298_pos, "")
-    rx298_cur."!cursor_debug"("PASS  ", "", " at pos=", rx298_pos)
-    .return (rx298_cur)
-  rx298_fail:
-    (rx298_rep, rx298_pos, $I10, $P10) = rx298_cur."!mark_fail"(0)
-    lt rx298_pos, -1, rx298_done
-    eq rx298_pos, -1, rx298_fail
-    jump $I10
-  rx298_done:
-    rx298_cur."!cursor_fail"()
-    rx298_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx298_cur)
+    add $I11, rx275_pos, 4
+    gt $I11, rx275_eos, rx275_fail
+    sub $I11, rx275_pos, rx275_off
+    substr $S10, rx275_tgt, $I11, 4
+    ne $S10, "else", rx275_fail
+    add rx275_pos, 4
+  # rx pass
+    rx275_cur."!cursor_pass"(rx275_pos, "")
+    rx275_cur."!cursor_debug"("PASS  ", "", " at pos=", rx275_pos)
+    .return (rx275_cur)
+  rx275_restart:
+    rx275_cur."!cursor_debug"("NEXT ", "")
+  rx275_fail:
+    (rx275_rep, rx275_pos, $I10, $P10) = rx275_cur."!mark_fail"(0)
+    lt rx275_pos, -1, rx275_done
+    eq rx275_pos, -1, rx275_fail
+    jump $I10
+  rx275_done:
+    rx275_cur."!cursor_fail"()
+    rx275_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx275_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<while>"  :subid("67_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx305_tgt
-    .local int rx305_pos
-    .local int rx305_off
-    .local int rx305_eos
-    .local int rx305_rep
-    .local pmc rx305_cur
-    (rx305_cur, rx305_pos, rx305_tgt) = self."!cursor_start"()
-    rx305_cur."!cursor_debug"("START ", "statement_control:sym<while>")
-    .lex unicode:"$\x{a2}", rx305_cur
-    .local pmc match
-    .lex "$/", match
-    length rx305_eos, rx305_tgt
-    gt rx305_pos, rx305_eos, rx305_done
-    set rx305_off, 0
-    lt rx305_pos, 2, rx305_start
-    sub rx305_off, rx305_pos, 1
-    substr rx305_tgt, rx305_tgt, rx305_off
-  rx305_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan308_done
-    goto rxscan308_scan
-  rxscan308_loop:
-    ($P10) = rx305_cur."from"()
-    inc $P10
-    set rx305_pos, $P10
-    ge rx305_pos, rx305_eos, rxscan308_done
-  rxscan308_scan:
-    set_addr $I10, rxscan308_loop
-    rx305_cur."!mark_push"(0, rx305_pos, $I10)
-  rxscan308_done:
+.sub "statement_control:sym<while>"  :subid("67_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx282_tgt
+    .local int rx282_pos
+    .local int rx282_off
+    .local int rx282_eos
+    .local int rx282_rep
+    .local pmc rx282_cur
+    (rx282_cur, rx282_pos, rx282_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx282_cur
+    .local pmc match
+    .lex "$/", match
+    length rx282_eos, rx282_tgt
+    gt rx282_pos, rx282_eos, rx282_done
+    set rx282_off, 0
+    lt rx282_pos, 2, rx282_start
+    sub rx282_off, rx282_pos, 1
+    substr rx282_tgt, rx282_tgt, rx282_off
+  rx282_start:
+    eq $I10, 1, rx282_restart
+    rx282_cur."!cursor_debug"("START ", "statement_control:sym<while>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan285_done
+    goto rxscan285_scan
+  rxscan285_loop:
+    ($P10) = rx282_cur."from"()
+    inc $P10
+    set rx282_pos, $P10
+    ge rx282_pos, rx282_eos, rxscan285_done
+  rxscan285_scan:
+    set_addr $I10, rxscan285_loop
+    rx282_cur."!mark_push"(0, rx282_pos, $I10)
+  rxscan285_done:
 .annotate 'line', 171
   # rx subcapture "sym"
-    set_addr $I10, rxcap_310_fail
-    rx305_cur."!mark_push"(0, rx305_pos, $I10)
-  alt309_0:
-    set_addr $I10, alt309_1
-    rx305_cur."!mark_push"(0, rx305_pos, $I10)
+    set_addr $I10, rxcap_287_fail
+    rx282_cur."!mark_push"(0, rx282_pos, $I10)
+  alt286_0:
+    set_addr $I10, alt286_1
+    rx282_cur."!mark_push"(0, rx282_pos, $I10)
   # rx literal  "while"
-    add $I11, rx305_pos, 5
-    gt $I11, rx305_eos, rx305_fail
-    sub $I11, rx305_pos, rx305_off
-    substr $S10, rx305_tgt, $I11, 5
-    ne $S10, "while", rx305_fail
-    add rx305_pos, 5
-    goto alt309_end
-  alt309_1:
+    add $I11, rx282_pos, 5
+    gt $I11, rx282_eos, rx282_fail
+    sub $I11, rx282_pos, rx282_off
+    substr $S10, rx282_tgt, $I11, 5
+    ne $S10, "while", rx282_fail
+    add rx282_pos, 5
+    goto alt286_end
+  alt286_1:
   # rx literal  "until"
-    add $I11, rx305_pos, 5
-    gt $I11, rx305_eos, rx305_fail
-    sub $I11, rx305_pos, rx305_off
-    substr $S10, rx305_tgt, $I11, 5
-    ne $S10, "until", rx305_fail
-    add rx305_pos, 5
-  alt309_end:
-    set_addr $I10, rxcap_310_fail
-    ($I12, $I11) = rx305_cur."!mark_peek"($I10)
-    rx305_cur."!cursor_pos"($I11)
-    ($P10) = rx305_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx305_pos, "")
-    rx305_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx282_pos, 5
+    gt $I11, rx282_eos, rx282_fail
+    sub $I11, rx282_pos, rx282_off
+    substr $S10, rx282_tgt, $I11, 5
+    ne $S10, "until", rx282_fail
+    add rx282_pos, 5
+  alt286_end:
+    set_addr $I10, rxcap_287_fail
+    ($I12, $I11) = rx282_cur."!mark_peek"($I10)
+    rx282_cur."!cursor_pos"($I11)
+    ($P10) = rx282_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx282_pos, "")
+    rx282_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_310_done
-  rxcap_310_fail:
-    goto rx305_fail
-  rxcap_310_done:
+    goto rxcap_287_done
+  rxcap_287_fail:
+    goto rx282_fail
+  rxcap_287_done:
   # rx charclass s
-    ge rx305_pos, rx305_eos, rx305_fail
-    sub $I10, rx305_pos, rx305_off
-    is_cclass $I11, 32, rx305_tgt, $I10
-    unless $I11, rx305_fail
-    inc rx305_pos
-  # rx subrule "ws" subtype=method negate=
-    rx305_cur."!cursor_pos"(rx305_pos)
-    $P10 = rx305_cur."ws"()
-    unless $P10, rx305_fail
-    rx305_pos = $P10."pos"()
+    ge rx282_pos, rx282_eos, rx282_fail
+    sub $I10, rx282_pos, rx282_off
+    is_cclass $I11, 32, rx282_tgt, $I10
+    unless $I11, rx282_fail
+    inc rx282_pos
+  # rx subrule "ws" subtype=method negate=
+    rx282_cur."!cursor_pos"(rx282_pos)
+    $P10 = rx282_cur."ws"()
+    unless $P10, rx282_fail
+    rx282_pos = $P10."pos"()
 .annotate 'line', 172
   # rx subrule "xblock" subtype=capture negate=
-    rx305_cur."!cursor_pos"(rx305_pos)
-    $P10 = rx305_cur."xblock"()
-    unless $P10, rx305_fail
-    rx305_cur."!mark_push"(0, -1, 0, $P10)
+    rx282_cur."!cursor_pos"(rx282_pos)
+    $P10 = rx282_cur."xblock"()
+    unless $P10, rx282_fail
+    rx282_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("xblock")
-    rx305_pos = $P10."pos"()
+    rx282_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx305_cur."!cursor_pos"(rx305_pos)
-    $P10 = rx305_cur."ws"()
-    unless $P10, rx305_fail
-    rx305_pos = $P10."pos"()
+    rx282_cur."!cursor_pos"(rx282_pos)
+    $P10 = rx282_cur."ws"()
+    unless $P10, rx282_fail
+    rx282_pos = $P10."pos"()
 .annotate 'line', 170
   # rx pass
-    rx305_cur."!cursor_pass"(rx305_pos, "statement_control:sym<while>")
-    rx305_cur."!cursor_debug"("PASS  ", "statement_control:sym<while>", " at pos=", rx305_pos)
-    .return (rx305_cur)
-  rx305_fail:
+    rx282_cur."!cursor_pass"(rx282_pos, "statement_control:sym<while>")
+    rx282_cur."!cursor_debug"("PASS  ", "statement_control:sym<while>", " at pos=", rx282_pos)
+    .return (rx282_cur)
+  rx282_restart:
 .annotate 'line', 4
-    (rx305_rep, rx305_pos, $I10, $P10) = rx305_cur."!mark_fail"(0)
-    lt rx305_pos, -1, rx305_done
-    eq rx305_pos, -1, rx305_fail
+    rx282_cur."!cursor_debug"("NEXT ", "statement_control:sym<while>")
+  rx282_fail:
+    (rx282_rep, rx282_pos, $I10, $P10) = rx282_cur."!mark_fail"(0)
+    lt rx282_pos, -1, rx282_done
+    eq rx282_pos, -1, rx282_fail
     jump $I10
-  rx305_done:
-    rx305_cur."!cursor_fail"()
-    rx305_cur."!cursor_debug"("FAIL  ", "statement_control:sym<while>")
-    .return (rx305_cur)
+  rx282_done:
+    rx282_cur."!cursor_fail"()
+    rx282_cur."!cursor_debug"("FAIL  ", "statement_control:sym<while>")
+    .return (rx282_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<while>"  :subid("68_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<while>"  :subid("68_1279529226.73787") :method
 .annotate 'line', 4
-    new $P307, "ResizablePMCArray"
-    push $P307, "until"
-    push $P307, "while"
-    .return ($P307)
+    new $P284, "ResizablePMCArray"
+    push $P284, "until"
+    push $P284, "while"
+    .return ($P284)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<repeat>"  :subid("69_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_control:sym<repeat>"  :subid("69_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx314_tgt
-    .local int rx314_pos
-    .local int rx314_off
-    .local int rx314_eos
-    .local int rx314_rep
-    .local pmc rx314_cur
-    (rx314_cur, rx314_pos, rx314_tgt) = self."!cursor_start"()
-    rx314_cur."!cursor_debug"("START ", "statement_control:sym<repeat>")
-    .lex unicode:"$\x{a2}", rx314_cur
+    .local string rx291_tgt
+    .local int rx291_pos
+    .local int rx291_off
+    .local int rx291_eos
+    .local int rx291_rep
+    .local pmc rx291_cur
+    (rx291_cur, rx291_pos, rx291_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx291_cur
     .local pmc match
     .lex "$/", match
-    length rx314_eos, rx314_tgt
-    gt rx314_pos, rx314_eos, rx314_done
-    set rx314_off, 0
-    lt rx314_pos, 2, rx314_start
-    sub rx314_off, rx314_pos, 1
-    substr rx314_tgt, rx314_tgt, rx314_off
-  rx314_start:
+    length rx291_eos, rx291_tgt
+    gt rx291_pos, rx291_eos, rx291_done
+    set rx291_off, 0
+    lt rx291_pos, 2, rx291_start
+    sub rx291_off, rx291_pos, 1
+    substr rx291_tgt, rx291_tgt, rx291_off
+  rx291_start:
+    eq $I10, 1, rx291_restart
+    rx291_cur."!cursor_debug"("START ", "statement_control:sym<repeat>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan317_done
-    goto rxscan317_scan
-  rxscan317_loop:
-    ($P10) = rx314_cur."from"()
+    ne $I10, -1, rxscan294_done
+    goto rxscan294_scan
+  rxscan294_loop:
+    ($P10) = rx291_cur."from"()
     inc $P10
-    set rx314_pos, $P10
-    ge rx314_pos, rx314_eos, rxscan317_done
-  rxscan317_scan:
-    set_addr $I10, rxscan317_loop
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
-  rxscan317_done:
+    set rx291_pos, $P10
+    ge rx291_pos, rx291_eos, rxscan294_done
+  rxscan294_scan:
+    set_addr $I10, rxscan294_loop
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  rxscan294_done:
 .annotate 'line', 176
   # rx subcapture "sym"
-    set_addr $I10, rxcap_318_fail
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
+    set_addr $I10, rxcap_295_fail
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
   # rx literal  "repeat"
-    add $I11, rx314_pos, 6
-    gt $I11, rx314_eos, rx314_fail
-    sub $I11, rx314_pos, rx314_off
-    substr $S10, rx314_tgt, $I11, 6
-    ne $S10, "repeat", rx314_fail
-    add rx314_pos, 6
-    set_addr $I10, rxcap_318_fail
-    ($I12, $I11) = rx314_cur."!mark_peek"($I10)
-    rx314_cur."!cursor_pos"($I11)
-    ($P10) = rx314_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx314_pos, "")
-    rx314_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx291_pos, 6
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 6
+    ne $S10, "repeat", rx291_fail
+    add rx291_pos, 6
+    set_addr $I10, rxcap_295_fail
+    ($I12, $I11) = rx291_cur."!mark_peek"($I10)
+    rx291_cur."!cursor_pos"($I11)
+    ($P10) = rx291_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx291_pos, "")
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_318_done
-  rxcap_318_fail:
-    goto rx314_fail
-  rxcap_318_done:
+    goto rxcap_295_done
+  rxcap_295_fail:
+    goto rx291_fail
+  rxcap_295_done:
   # rx charclass s
-    ge rx314_pos, rx314_eos, rx314_fail
-    sub $I10, rx314_pos, rx314_off
-    is_cclass $I11, 32, rx314_tgt, $I10
-    unless $I11, rx314_fail
-    inc rx314_pos
-  # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
-  alt320_0:
+    ge rx291_pos, rx291_eos, rx291_fail
+    sub $I10, rx291_pos, rx291_off
+    is_cclass $I11, 32, rx291_tgt, $I10
+    unless $I11, rx291_fail
+    inc rx291_pos
+  # rx subrule "ws" subtype=method negate=
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
+  alt297_0:
 .annotate 'line', 177
-    set_addr $I10, alt320_1
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
+    set_addr $I10, alt297_1
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
 .annotate 'line', 178
   # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
   # rx subcapture "wu"
-    set_addr $I10, rxcap_323_fail
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
-  alt322_0:
-    set_addr $I10, alt322_1
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
+    set_addr $I10, rxcap_300_fail
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  alt299_0:
+    set_addr $I10, alt299_1
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
   # rx literal  "while"
-    add $I11, rx314_pos, 5
-    gt $I11, rx314_eos, rx314_fail
-    sub $I11, rx314_pos, rx314_off
-    substr $S10, rx314_tgt, $I11, 5
-    ne $S10, "while", rx314_fail
-    add rx314_pos, 5
-    goto alt322_end
-  alt322_1:
+    add $I11, rx291_pos, 5
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 5
+    ne $S10, "while", rx291_fail
+    add rx291_pos, 5
+    goto alt299_end
+  alt299_1:
   # rx literal  "until"
-    add $I11, rx314_pos, 5
-    gt $I11, rx314_eos, rx314_fail
-    sub $I11, rx314_pos, rx314_off
-    substr $S10, rx314_tgt, $I11, 5
-    ne $S10, "until", rx314_fail
-    add rx314_pos, 5
-  alt322_end:
-    set_addr $I10, rxcap_323_fail
-    ($I12, $I11) = rx314_cur."!mark_peek"($I10)
-    rx314_cur."!cursor_pos"($I11)
-    ($P10) = rx314_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx314_pos, "")
-    rx314_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx291_pos, 5
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 5
+    ne $S10, "until", rx291_fail
+    add rx291_pos, 5
+  alt299_end:
+    set_addr $I10, rxcap_300_fail
+    ($I12, $I11) = rx291_cur."!mark_peek"($I10)
+    rx291_cur."!cursor_pos"($I11)
+    ($P10) = rx291_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx291_pos, "")
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("wu")
-    goto rxcap_323_done
-  rxcap_323_fail:
-    goto rx314_fail
-  rxcap_323_done:
+    goto rxcap_300_done
+  rxcap_300_fail:
+    goto rx291_fail
+  rxcap_300_done:
   # rx charclass s
-    ge rx314_pos, rx314_eos, rx314_fail
-    sub $I10, rx314_pos, rx314_off
-    is_cclass $I11, 32, rx314_tgt, $I10
-    unless $I11, rx314_fail
-    inc rx314_pos
-  # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
+    ge rx291_pos, rx291_eos, rx291_fail
+    sub $I10, rx291_pos, rx291_off
+    is_cclass $I11, 32, rx291_tgt, $I10
+    unless $I11, rx291_fail
+    inc rx291_pos
+  # rx subrule "ws" subtype=method negate=
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
   # rx subrule "xblock" subtype=capture negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."xblock"()
-    unless $P10, rx314_fail
-    rx314_cur."!mark_push"(0, -1, 0, $P10)
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."xblock"()
+    unless $P10, rx291_fail
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("xblock")
-    rx314_pos = $P10."pos"()
+    rx291_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
-    goto alt320_end
-  alt320_1:
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
+    goto alt297_end
+  alt297_1:
 .annotate 'line', 179
   # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
   # rx subrule "pblock" subtype=capture negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."pblock"()
-    unless $P10, rx314_fail
-    rx314_cur."!mark_push"(0, -1, 0, $P10)
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."pblock"()
+    unless $P10, rx291_fail
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("pblock")
-    rx314_pos = $P10."pos"()
+    rx291_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
   # rx subcapture "wu"
-    set_addr $I10, rxcap_329_fail
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
-  alt328_0:
-    set_addr $I10, alt328_1
-    rx314_cur."!mark_push"(0, rx314_pos, $I10)
+    set_addr $I10, rxcap_306_fail
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  alt305_0:
+    set_addr $I10, alt305_1
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
   # rx literal  "while"
-    add $I11, rx314_pos, 5
-    gt $I11, rx314_eos, rx314_fail
-    sub $I11, rx314_pos, rx314_off
-    substr $S10, rx314_tgt, $I11, 5
-    ne $S10, "while", rx314_fail
-    add rx314_pos, 5
-    goto alt328_end
-  alt328_1:
+    add $I11, rx291_pos, 5
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 5
+    ne $S10, "while", rx291_fail
+    add rx291_pos, 5
+    goto alt305_end
+  alt305_1:
   # rx literal  "until"
-    add $I11, rx314_pos, 5
-    gt $I11, rx314_eos, rx314_fail
-    sub $I11, rx314_pos, rx314_off
-    substr $S10, rx314_tgt, $I11, 5
-    ne $S10, "until", rx314_fail
-    add rx314_pos, 5
-  alt328_end:
-    set_addr $I10, rxcap_329_fail
-    ($I12, $I11) = rx314_cur."!mark_peek"($I10)
-    rx314_cur."!cursor_pos"($I11)
-    ($P10) = rx314_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx314_pos, "")
-    rx314_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx291_pos, 5
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 5
+    ne $S10, "until", rx291_fail
+    add rx291_pos, 5
+  alt305_end:
+    set_addr $I10, rxcap_306_fail
+    ($I12, $I11) = rx291_cur."!mark_peek"($I10)
+    rx291_cur."!cursor_pos"($I11)
+    ($P10) = rx291_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx291_pos, "")
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("wu")
-    goto rxcap_329_done
-  rxcap_329_fail:
-    goto rx314_fail
-  rxcap_329_done:
+    goto rxcap_306_done
+  rxcap_306_fail:
+    goto rx291_fail
+  rxcap_306_done:
   # rx charclass s
-    ge rx314_pos, rx314_eos, rx314_fail
-    sub $I10, rx314_pos, rx314_off
-    is_cclass $I11, 32, rx314_tgt, $I10
-    unless $I11, rx314_fail
-    inc rx314_pos
-  # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
+    ge rx291_pos, rx291_eos, rx291_fail
+    sub $I10, rx291_pos, rx291_off
+    is_cclass $I11, 32, rx291_tgt, $I10
+    unless $I11, rx291_fail
+    inc rx291_pos
+  # rx subrule "ws" subtype=method negate=
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."EXPR"()
-    unless $P10, rx314_fail
-    rx314_cur."!mark_push"(0, -1, 0, $P10)
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."EXPR"()
+    unless $P10, rx291_fail
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("EXPR")
-    rx314_pos = $P10."pos"()
+    rx291_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
-  alt320_end:
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
+  alt297_end:
 .annotate 'line', 180
   # rx subrule "ws" subtype=method negate=
-    rx314_cur."!cursor_pos"(rx314_pos)
-    $P10 = rx314_cur."ws"()
-    unless $P10, rx314_fail
-    rx314_pos = $P10."pos"()
+    rx291_cur."!cursor_pos"(rx291_pos)
+    $P10 = rx291_cur."ws"()
+    unless $P10, rx291_fail
+    rx291_pos = $P10."pos"()
 .annotate 'line', 175
   # rx pass
-    rx314_cur."!cursor_pass"(rx314_pos, "statement_control:sym<repeat>")
-    rx314_cur."!cursor_debug"("PASS  ", "statement_control:sym<repeat>", " at pos=", rx314_pos)
-    .return (rx314_cur)
-  rx314_fail:
+    rx291_cur."!cursor_pass"(rx291_pos, "statement_control:sym<repeat>")
+    rx291_cur."!cursor_debug"("PASS  ", "statement_control:sym<repeat>", " at pos=", rx291_pos)
+    .return (rx291_cur)
+  rx291_restart:
 .annotate 'line', 4
-    (rx314_rep, rx314_pos, $I10, $P10) = rx314_cur."!mark_fail"(0)
-    lt rx314_pos, -1, rx314_done
-    eq rx314_pos, -1, rx314_fail
+    rx291_cur."!cursor_debug"("NEXT ", "statement_control:sym<repeat>")
+  rx291_fail:
+    (rx291_rep, rx291_pos, $I10, $P10) = rx291_cur."!mark_fail"(0)
+    lt rx291_pos, -1, rx291_done
+    eq rx291_pos, -1, rx291_fail
     jump $I10
-  rx314_done:
-    rx314_cur."!cursor_fail"()
-    rx314_cur."!cursor_debug"("FAIL  ", "statement_control:sym<repeat>")
-    .return (rx314_cur)
+  rx291_done:
+    rx291_cur."!cursor_fail"()
+    rx291_cur."!cursor_debug"("FAIL  ", "statement_control:sym<repeat>")
+    .return (rx291_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<repeat>"  :subid("70_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<repeat>"  :subid("70_1279529226.73787") :method
 .annotate 'line', 4
-    new $P316, "ResizablePMCArray"
-    push $P316, "repeat"
-    .return ($P316)
+    new $P293, "ResizablePMCArray"
+    push $P293, "repeat"
+    .return ($P293)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<for>"  :subid("71_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_control:sym<for>"  :subid("71_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx334_tgt
-    .local int rx334_pos
-    .local int rx334_off
-    .local int rx334_eos
-    .local int rx334_rep
-    .local pmc rx334_cur
-    (rx334_cur, rx334_pos, rx334_tgt) = self."!cursor_start"()
-    rx334_cur."!cursor_debug"("START ", "statement_control:sym<for>")
-    .lex unicode:"$\x{a2}", rx334_cur
+    .local string rx311_tgt
+    .local int rx311_pos
+    .local int rx311_off
+    .local int rx311_eos
+    .local int rx311_rep
+    .local pmc rx311_cur
+    (rx311_cur, rx311_pos, rx311_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx311_cur
     .local pmc match
     .lex "$/", match
-    length rx334_eos, rx334_tgt
-    gt rx334_pos, rx334_eos, rx334_done
-    set rx334_off, 0
-    lt rx334_pos, 2, rx334_start
-    sub rx334_off, rx334_pos, 1
-    substr rx334_tgt, rx334_tgt, rx334_off
-  rx334_start:
+    length rx311_eos, rx311_tgt
+    gt rx311_pos, rx311_eos, rx311_done
+    set rx311_off, 0
+    lt rx311_pos, 2, rx311_start
+    sub rx311_off, rx311_pos, 1
+    substr rx311_tgt, rx311_tgt, rx311_off
+  rx311_start:
+    eq $I10, 1, rx311_restart
+    rx311_cur."!cursor_debug"("START ", "statement_control:sym<for>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan337_done
-    goto rxscan337_scan
-  rxscan337_loop:
-    ($P10) = rx334_cur."from"()
+    ne $I10, -1, rxscan314_done
+    goto rxscan314_scan
+  rxscan314_loop:
+    ($P10) = rx311_cur."from"()
     inc $P10
-    set rx334_pos, $P10
-    ge rx334_pos, rx334_eos, rxscan337_done
-  rxscan337_scan:
-    set_addr $I10, rxscan337_loop
-    rx334_cur."!mark_push"(0, rx334_pos, $I10)
-  rxscan337_done:
+    set rx311_pos, $P10
+    ge rx311_pos, rx311_eos, rxscan314_done
+  rxscan314_scan:
+    set_addr $I10, rxscan314_loop
+    rx311_cur."!mark_push"(0, rx311_pos, $I10)
+  rxscan314_done:
 .annotate 'line', 184
   # rx subcapture "sym"
-    set_addr $I10, rxcap_338_fail
-    rx334_cur."!mark_push"(0, rx334_pos, $I10)
+    set_addr $I10, rxcap_315_fail
+    rx311_cur."!mark_push"(0, rx311_pos, $I10)
   # rx literal  "for"
-    add $I11, rx334_pos, 3
-    gt $I11, rx334_eos, rx334_fail
-    sub $I11, rx334_pos, rx334_off
-    substr $S10, rx334_tgt, $I11, 3
-    ne $S10, "for", rx334_fail
-    add rx334_pos, 3
-    set_addr $I10, rxcap_338_fail
-    ($I12, $I11) = rx334_cur."!mark_peek"($I10)
-    rx334_cur."!cursor_pos"($I11)
-    ($P10) = rx334_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx334_pos, "")
-    rx334_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx311_pos, 3
+    gt $I11, rx311_eos, rx311_fail
+    sub $I11, rx311_pos, rx311_off
+    substr $S10, rx311_tgt, $I11, 3
+    ne $S10, "for", rx311_fail
+    add rx311_pos, 3
+    set_addr $I10, rxcap_315_fail
+    ($I12, $I11) = rx311_cur."!mark_peek"($I10)
+    rx311_cur."!cursor_pos"($I11)
+    ($P10) = rx311_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx311_pos, "")
+    rx311_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_338_done
-  rxcap_338_fail:
-    goto rx334_fail
-  rxcap_338_done:
+    goto rxcap_315_done
+  rxcap_315_fail:
+    goto rx311_fail
+  rxcap_315_done:
   # rx charclass s
-    ge rx334_pos, rx334_eos, rx334_fail
-    sub $I10, rx334_pos, rx334_off
-    is_cclass $I11, 32, rx334_tgt, $I10
-    unless $I11, rx334_fail
-    inc rx334_pos
-  # rx subrule "ws" subtype=method negate=
-    rx334_cur."!cursor_pos"(rx334_pos)
-    $P10 = rx334_cur."ws"()
-    unless $P10, rx334_fail
-    rx334_pos = $P10."pos"()
+    ge rx311_pos, rx311_eos, rx311_fail
+    sub $I10, rx311_pos, rx311_off
+    is_cclass $I11, 32, rx311_tgt, $I10
+    unless $I11, rx311_fail
+    inc rx311_pos
+  # rx subrule "ws" subtype=method negate=
+    rx311_cur."!cursor_pos"(rx311_pos)
+    $P10 = rx311_cur."ws"()
+    unless $P10, rx311_fail
+    rx311_pos = $P10."pos"()
 .annotate 'line', 185
   # rx subrule "xblock" subtype=capture negate=
-    rx334_cur."!cursor_pos"(rx334_pos)
-    $P10 = rx334_cur."xblock"()
-    unless $P10, rx334_fail
-    rx334_cur."!mark_push"(0, -1, 0, $P10)
+    rx311_cur."!cursor_pos"(rx311_pos)
+    $P10 = rx311_cur."xblock"()
+    unless $P10, rx311_fail
+    rx311_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("xblock")
-    rx334_pos = $P10."pos"()
+    rx311_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx334_cur."!cursor_pos"(rx334_pos)
-    $P10 = rx334_cur."ws"()
-    unless $P10, rx334_fail
-    rx334_pos = $P10."pos"()
+    rx311_cur."!cursor_pos"(rx311_pos)
+    $P10 = rx311_cur."ws"()
+    unless $P10, rx311_fail
+    rx311_pos = $P10."pos"()
 .annotate 'line', 183
   # rx pass
-    rx334_cur."!cursor_pass"(rx334_pos, "statement_control:sym<for>")
-    rx334_cur."!cursor_debug"("PASS  ", "statement_control:sym<for>", " at pos=", rx334_pos)
-    .return (rx334_cur)
-  rx334_fail:
+    rx311_cur."!cursor_pass"(rx311_pos, "statement_control:sym<for>")
+    rx311_cur."!cursor_debug"("PASS  ", "statement_control:sym<for>", " at pos=", rx311_pos)
+    .return (rx311_cur)
+  rx311_restart:
 .annotate 'line', 4
-    (rx334_rep, rx334_pos, $I10, $P10) = rx334_cur."!mark_fail"(0)
-    lt rx334_pos, -1, rx334_done
-    eq rx334_pos, -1, rx334_fail
+    rx311_cur."!cursor_debug"("NEXT ", "statement_control:sym<for>")
+  rx311_fail:
+    (rx311_rep, rx311_pos, $I10, $P10) = rx311_cur."!mark_fail"(0)
+    lt rx311_pos, -1, rx311_done
+    eq rx311_pos, -1, rx311_fail
     jump $I10
-  rx334_done:
-    rx334_cur."!cursor_fail"()
-    rx334_cur."!cursor_debug"("FAIL  ", "statement_control:sym<for>")
-    .return (rx334_cur)
+  rx311_done:
+    rx311_cur."!cursor_fail"()
+    rx311_cur."!cursor_debug"("FAIL  ", "statement_control:sym<for>")
+    .return (rx311_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<for>"  :subid("72_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<for>"  :subid("72_1279529226.73787") :method
 .annotate 'line', 4
-    new $P336, "ResizablePMCArray"
-    push $P336, "for"
-    .return ($P336)
+    new $P313, "ResizablePMCArray"
+    push $P313, "for"
+    .return ($P313)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<CATCH>"  :subid("73_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_control:sym<CATCH>"  :subid("73_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx342_tgt
-    .local int rx342_pos
-    .local int rx342_off
-    .local int rx342_eos
-    .local int rx342_rep
-    .local pmc rx342_cur
-    (rx342_cur, rx342_pos, rx342_tgt) = self."!cursor_start"()
-    rx342_cur."!cursor_debug"("START ", "statement_control:sym<CATCH>")
-    .lex unicode:"$\x{a2}", rx342_cur
+    .local string rx319_tgt
+    .local int rx319_pos
+    .local int rx319_off
+    .local int rx319_eos
+    .local int rx319_rep
+    .local pmc rx319_cur
+    (rx319_cur, rx319_pos, rx319_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx319_cur
     .local pmc match
     .lex "$/", match
-    length rx342_eos, rx342_tgt
-    gt rx342_pos, rx342_eos, rx342_done
-    set rx342_off, 0
-    lt rx342_pos, 2, rx342_start
-    sub rx342_off, rx342_pos, 1
-    substr rx342_tgt, rx342_tgt, rx342_off
-  rx342_start:
+    length rx319_eos, rx319_tgt
+    gt rx319_pos, rx319_eos, rx319_done
+    set rx319_off, 0
+    lt rx319_pos, 2, rx319_start
+    sub rx319_off, rx319_pos, 1
+    substr rx319_tgt, rx319_tgt, rx319_off
+  rx319_start:
+    eq $I10, 1, rx319_restart
+    rx319_cur."!cursor_debug"("START ", "statement_control:sym<CATCH>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan345_done
-    goto rxscan345_scan
-  rxscan345_loop:
-    ($P10) = rx342_cur."from"()
+    ne $I10, -1, rxscan322_done
+    goto rxscan322_scan
+  rxscan322_loop:
+    ($P10) = rx319_cur."from"()
     inc $P10
-    set rx342_pos, $P10
-    ge rx342_pos, rx342_eos, rxscan345_done
-  rxscan345_scan:
-    set_addr $I10, rxscan345_loop
-    rx342_cur."!mark_push"(0, rx342_pos, $I10)
-  rxscan345_done:
+    set rx319_pos, $P10
+    ge rx319_pos, rx319_eos, rxscan322_done
+  rxscan322_scan:
+    set_addr $I10, rxscan322_loop
+    rx319_cur."!mark_push"(0, rx319_pos, $I10)
+  rxscan322_done:
 .annotate 'line', 189
   # rx subcapture "sym"
-    set_addr $I10, rxcap_346_fail
-    rx342_cur."!mark_push"(0, rx342_pos, $I10)
+    set_addr $I10, rxcap_323_fail
+    rx319_cur."!mark_push"(0, rx319_pos, $I10)
   # rx literal  "CATCH"
-    add $I11, rx342_pos, 5
-    gt $I11, rx342_eos, rx342_fail
-    sub $I11, rx342_pos, rx342_off
-    substr $S10, rx342_tgt, $I11, 5
-    ne $S10, "CATCH", rx342_fail
-    add rx342_pos, 5
-    set_addr $I10, rxcap_346_fail
-    ($I12, $I11) = rx342_cur."!mark_peek"($I10)
-    rx342_cur."!cursor_pos"($I11)
-    ($P10) = rx342_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx342_pos, "")
-    rx342_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx319_pos, 5
+    gt $I11, rx319_eos, rx319_fail
+    sub $I11, rx319_pos, rx319_off
+    substr $S10, rx319_tgt, $I11, 5
+    ne $S10, "CATCH", rx319_fail
+    add rx319_pos, 5
+    set_addr $I10, rxcap_323_fail
+    ($I12, $I11) = rx319_cur."!mark_peek"($I10)
+    rx319_cur."!cursor_pos"($I11)
+    ($P10) = rx319_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx319_pos, "")
+    rx319_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_346_done
-  rxcap_346_fail:
-    goto rx342_fail
-  rxcap_346_done:
+    goto rxcap_323_done
+  rxcap_323_fail:
+    goto rx319_fail
+  rxcap_323_done:
   # rx charclass s
-    ge rx342_pos, rx342_eos, rx342_fail
-    sub $I10, rx342_pos, rx342_off
-    is_cclass $I11, 32, rx342_tgt, $I10
-    unless $I11, rx342_fail
-    inc rx342_pos
-  # rx subrule "ws" subtype=method negate=
-    rx342_cur."!cursor_pos"(rx342_pos)
-    $P10 = rx342_cur."ws"()
-    unless $P10, rx342_fail
-    rx342_pos = $P10."pos"()
+    ge rx319_pos, rx319_eos, rx319_fail
+    sub $I10, rx319_pos, rx319_off
+    is_cclass $I11, 32, rx319_tgt, $I10
+    unless $I11, rx319_fail
+    inc rx319_pos
+  # rx subrule "ws" subtype=method negate=
+    rx319_cur."!cursor_pos"(rx319_pos)
+    $P10 = rx319_cur."ws"()
+    unless $P10, rx319_fail
+    rx319_pos = $P10."pos"()
 .annotate 'line', 190
   # rx subrule "block" subtype=capture negate=
-    rx342_cur."!cursor_pos"(rx342_pos)
-    $P10 = rx342_cur."block"()
-    unless $P10, rx342_fail
-    rx342_cur."!mark_push"(0, -1, 0, $P10)
+    rx319_cur."!cursor_pos"(rx319_pos)
+    $P10 = rx319_cur."block"()
+    unless $P10, rx319_fail
+    rx319_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("block")
-    rx342_pos = $P10."pos"()
+    rx319_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx342_cur."!cursor_pos"(rx342_pos)
-    $P10 = rx342_cur."ws"()
-    unless $P10, rx342_fail
-    rx342_pos = $P10."pos"()
+    rx319_cur."!cursor_pos"(rx319_pos)
+    $P10 = rx319_cur."ws"()
+    unless $P10, rx319_fail
+    rx319_pos = $P10."pos"()
 .annotate 'line', 188
   # rx pass
-    rx342_cur."!cursor_pass"(rx342_pos, "statement_control:sym<CATCH>")
-    rx342_cur."!cursor_debug"("PASS  ", "statement_control:sym<CATCH>", " at pos=", rx342_pos)
-    .return (rx342_cur)
-  rx342_fail:
+    rx319_cur."!cursor_pass"(rx319_pos, "statement_control:sym<CATCH>")
+    rx319_cur."!cursor_debug"("PASS  ", "statement_control:sym<CATCH>", " at pos=", rx319_pos)
+    .return (rx319_cur)
+  rx319_restart:
 .annotate 'line', 4
-    (rx342_rep, rx342_pos, $I10, $P10) = rx342_cur."!mark_fail"(0)
-    lt rx342_pos, -1, rx342_done
-    eq rx342_pos, -1, rx342_fail
+    rx319_cur."!cursor_debug"("NEXT ", "statement_control:sym<CATCH>")
+  rx319_fail:
+    (rx319_rep, rx319_pos, $I10, $P10) = rx319_cur."!mark_fail"(0)
+    lt rx319_pos, -1, rx319_done
+    eq rx319_pos, -1, rx319_fail
     jump $I10
-  rx342_done:
-    rx342_cur."!cursor_fail"()
-    rx342_cur."!cursor_debug"("FAIL  ", "statement_control:sym<CATCH>")
-    .return (rx342_cur)
+  rx319_done:
+    rx319_cur."!cursor_fail"()
+    rx319_cur."!cursor_debug"("FAIL  ", "statement_control:sym<CATCH>")
+    .return (rx319_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<CATCH>"  :subid("74_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<CATCH>"  :subid("74_1279529226.73787") :method
 .annotate 'line', 4
-    new $P344, "ResizablePMCArray"
-    push $P344, "CATCH"
-    .return ($P344)
+    new $P321, "ResizablePMCArray"
+    push $P321, "CATCH"
+    .return ($P321)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_control:sym<CONTROL>"  :subid("75_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_control:sym<CONTROL>"  :subid("75_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx350_tgt
-    .local int rx350_pos
-    .local int rx350_off
-    .local int rx350_eos
-    .local int rx350_rep
-    .local pmc rx350_cur
-    (rx350_cur, rx350_pos, rx350_tgt) = self."!cursor_start"()
-    rx350_cur."!cursor_debug"("START ", "statement_control:sym<CONTROL>")
-    .lex unicode:"$\x{a2}", rx350_cur
+    .local string rx327_tgt
+    .local int rx327_pos
+    .local int rx327_off
+    .local int rx327_eos
+    .local int rx327_rep
+    .local pmc rx327_cur
+    (rx327_cur, rx327_pos, rx327_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx327_cur
     .local pmc match
     .lex "$/", match
-    length rx350_eos, rx350_tgt
-    gt rx350_pos, rx350_eos, rx350_done
-    set rx350_off, 0
-    lt rx350_pos, 2, rx350_start
-    sub rx350_off, rx350_pos, 1
-    substr rx350_tgt, rx350_tgt, rx350_off
-  rx350_start:
+    length rx327_eos, rx327_tgt
+    gt rx327_pos, rx327_eos, rx327_done
+    set rx327_off, 0
+    lt rx327_pos, 2, rx327_start
+    sub rx327_off, rx327_pos, 1
+    substr rx327_tgt, rx327_tgt, rx327_off
+  rx327_start:
+    eq $I10, 1, rx327_restart
+    rx327_cur."!cursor_debug"("START ", "statement_control:sym<CONTROL>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan353_done
-    goto rxscan353_scan
-  rxscan353_loop:
-    ($P10) = rx350_cur."from"()
+    ne $I10, -1, rxscan330_done
+    goto rxscan330_scan
+  rxscan330_loop:
+    ($P10) = rx327_cur."from"()
     inc $P10
-    set rx350_pos, $P10
-    ge rx350_pos, rx350_eos, rxscan353_done
-  rxscan353_scan:
-    set_addr $I10, rxscan353_loop
-    rx350_cur."!mark_push"(0, rx350_pos, $I10)
-  rxscan353_done:
+    set rx327_pos, $P10
+    ge rx327_pos, rx327_eos, rxscan330_done
+  rxscan330_scan:
+    set_addr $I10, rxscan330_loop
+    rx327_cur."!mark_push"(0, rx327_pos, $I10)
+  rxscan330_done:
 .annotate 'line', 194
   # rx subcapture "sym"
-    set_addr $I10, rxcap_354_fail
-    rx350_cur."!mark_push"(0, rx350_pos, $I10)
+    set_addr $I10, rxcap_331_fail
+    rx327_cur."!mark_push"(0, rx327_pos, $I10)
   # rx literal  "CONTROL"
-    add $I11, rx350_pos, 7
-    gt $I11, rx350_eos, rx350_fail
-    sub $I11, rx350_pos, rx350_off
-    substr $S10, rx350_tgt, $I11, 7
-    ne $S10, "CONTROL", rx350_fail
-    add rx350_pos, 7
-    set_addr $I10, rxcap_354_fail
-    ($I12, $I11) = rx350_cur."!mark_peek"($I10)
-    rx350_cur."!cursor_pos"($I11)
-    ($P10) = rx350_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx350_pos, "")
-    rx350_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx327_pos, 7
+    gt $I11, rx327_eos, rx327_fail
+    sub $I11, rx327_pos, rx327_off
+    substr $S10, rx327_tgt, $I11, 7
+    ne $S10, "CONTROL", rx327_fail
+    add rx327_pos, 7
+    set_addr $I10, rxcap_331_fail
+    ($I12, $I11) = rx327_cur."!mark_peek"($I10)
+    rx327_cur."!cursor_pos"($I11)
+    ($P10) = rx327_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx327_pos, "")
+    rx327_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_354_done
-  rxcap_354_fail:
-    goto rx350_fail
-  rxcap_354_done:
+    goto rxcap_331_done
+  rxcap_331_fail:
+    goto rx327_fail
+  rxcap_331_done:
   # rx charclass s
-    ge rx350_pos, rx350_eos, rx350_fail
-    sub $I10, rx350_pos, rx350_off
-    is_cclass $I11, 32, rx350_tgt, $I10
-    unless $I11, rx350_fail
-    inc rx350_pos
-  # rx subrule "ws" subtype=method negate=
-    rx350_cur."!cursor_pos"(rx350_pos)
-    $P10 = rx350_cur."ws"()
-    unless $P10, rx350_fail
-    rx350_pos = $P10."pos"()
+    ge rx327_pos, rx327_eos, rx327_fail
+    sub $I10, rx327_pos, rx327_off
+    is_cclass $I11, 32, rx327_tgt, $I10
+    unless $I11, rx327_fail
+    inc rx327_pos
+  # rx subrule "ws" subtype=method negate=
+    rx327_cur."!cursor_pos"(rx327_pos)
+    $P10 = rx327_cur."ws"()
+    unless $P10, rx327_fail
+    rx327_pos = $P10."pos"()
 .annotate 'line', 195
   # rx subrule "block" subtype=capture negate=
-    rx350_cur."!cursor_pos"(rx350_pos)
-    $P10 = rx350_cur."block"()
-    unless $P10, rx350_fail
-    rx350_cur."!mark_push"(0, -1, 0, $P10)
+    rx327_cur."!cursor_pos"(rx327_pos)
+    $P10 = rx327_cur."block"()
+    unless $P10, rx327_fail
+    rx327_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("block")
-    rx350_pos = $P10."pos"()
+    rx327_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx350_cur."!cursor_pos"(rx350_pos)
-    $P10 = rx350_cur."ws"()
-    unless $P10, rx350_fail
-    rx350_pos = $P10."pos"()
+    rx327_cur."!cursor_pos"(rx327_pos)
+    $P10 = rx327_cur."ws"()
+    unless $P10, rx327_fail
+    rx327_pos = $P10."pos"()
 .annotate 'line', 193
   # rx pass
-    rx350_cur."!cursor_pass"(rx350_pos, "statement_control:sym<CONTROL>")
-    rx350_cur."!cursor_debug"("PASS  ", "statement_control:sym<CONTROL>", " at pos=", rx350_pos)
-    .return (rx350_cur)
-  rx350_fail:
+    rx327_cur."!cursor_pass"(rx327_pos, "statement_control:sym<CONTROL>")
+    rx327_cur."!cursor_debug"("PASS  ", "statement_control:sym<CONTROL>", " at pos=", rx327_pos)
+    .return (rx327_cur)
+  rx327_restart:
 .annotate 'line', 4
-    (rx350_rep, rx350_pos, $I10, $P10) = rx350_cur."!mark_fail"(0)
-    lt rx350_pos, -1, rx350_done
-    eq rx350_pos, -1, rx350_fail
+    rx327_cur."!cursor_debug"("NEXT ", "statement_control:sym<CONTROL>")
+  rx327_fail:
+    (rx327_rep, rx327_pos, $I10, $P10) = rx327_cur."!mark_fail"(0)
+    lt rx327_pos, -1, rx327_done
+    eq rx327_pos, -1, rx327_fail
     jump $I10
-  rx350_done:
-    rx350_cur."!cursor_fail"()
-    rx350_cur."!cursor_debug"("FAIL  ", "statement_control:sym<CONTROL>")
-    .return (rx350_cur)
+  rx327_done:
+    rx327_cur."!cursor_fail"()
+    rx327_cur."!cursor_debug"("FAIL  ", "statement_control:sym<CONTROL>")
+    .return (rx327_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_control:sym<CONTROL>"  :subid("76_1278500537.15927") :method
+.sub "!PREFIX__statement_control:sym<CONTROL>"  :subid("76_1279529226.73787") :method
 .annotate 'line', 4
-    new $P352, "ResizablePMCArray"
-    push $P352, "CONTROL"
-    .return ($P352)
+    new $P329, "ResizablePMCArray"
+    push $P329, "CONTROL"
+    .return ($P329)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_prefix"  :subid("77_1278500537.15927") :method
+.sub "statement_prefix"  :subid("77_1279529226.73787") :method
 .annotate 'line', 198
-    $P358 = self."!protoregex"("statement_prefix")
-    .return ($P358)
+    $P335 = self."!protoregex"("statement_prefix")
+    .return ($P335)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_prefix"  :subid("78_1278500537.15927") :method
+.sub "!PREFIX__statement_prefix"  :subid("78_1279529226.73787") :method
 .annotate 'line', 198
-    $P360 = self."!PREFIX__!protoregex"("statement_prefix")
-    .return ($P360)
+    $P337 = self."!PREFIX__!protoregex"("statement_prefix")
+    .return ($P337)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_prefix:sym<INIT>"  :subid("79_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_prefix:sym<INIT>"  :subid("79_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx362_tgt
-    .local int rx362_pos
-    .local int rx362_off
-    .local int rx362_eos
-    .local int rx362_rep
-    .local pmc rx362_cur
-    (rx362_cur, rx362_pos, rx362_tgt) = self."!cursor_start"()
-    rx362_cur."!cursor_debug"("START ", "statement_prefix:sym<INIT>")
-    .lex unicode:"$\x{a2}", rx362_cur
-    .local pmc match
-    .lex "$/", match
-    length rx362_eos, rx362_tgt
-    gt rx362_pos, rx362_eos, rx362_done
-    set rx362_off, 0
-    lt rx362_pos, 2, rx362_start
-    sub rx362_off, rx362_pos, 1
-    substr rx362_tgt, rx362_tgt, rx362_off
-  rx362_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan366_done
-    goto rxscan366_scan
-  rxscan366_loop:
-    ($P10) = rx362_cur."from"()
-    inc $P10
-    set rx362_pos, $P10
-    ge rx362_pos, rx362_eos, rxscan366_done
-  rxscan366_scan:
-    set_addr $I10, rxscan366_loop
-    rx362_cur."!mark_push"(0, rx362_pos, $I10)
-  rxscan366_done:
+    .local string rx339_tgt
+    .local int rx339_pos
+    .local int rx339_off
+    .local int rx339_eos
+    .local int rx339_rep
+    .local pmc rx339_cur
+    (rx339_cur, rx339_pos, rx339_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx339_cur
+    .local pmc match
+    .lex "$/", match
+    length rx339_eos, rx339_tgt
+    gt rx339_pos, rx339_eos, rx339_done
+    set rx339_off, 0
+    lt rx339_pos, 2, rx339_start
+    sub rx339_off, rx339_pos, 1
+    substr rx339_tgt, rx339_tgt, rx339_off
+  rx339_start:
+    eq $I10, 1, rx339_restart
+    rx339_cur."!cursor_debug"("START ", "statement_prefix:sym<INIT>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan343_done
+    goto rxscan343_scan
+  rxscan343_loop:
+    ($P10) = rx339_cur."from"()
+    inc $P10
+    set rx339_pos, $P10
+    ge rx339_pos, rx339_eos, rxscan343_done
+  rxscan343_scan:
+    set_addr $I10, rxscan343_loop
+    rx339_cur."!mark_push"(0, rx339_pos, $I10)
+  rxscan343_done:
 .annotate 'line', 199
   # rx subcapture "sym"
-    set_addr $I10, rxcap_367_fail
-    rx362_cur."!mark_push"(0, rx362_pos, $I10)
+    set_addr $I10, rxcap_344_fail
+    rx339_cur."!mark_push"(0, rx339_pos, $I10)
   # rx literal  "INIT"
-    add $I11, rx362_pos, 4
-    gt $I11, rx362_eos, rx362_fail
-    sub $I11, rx362_pos, rx362_off
-    substr $S10, rx362_tgt, $I11, 4
-    ne $S10, "INIT", rx362_fail
-    add rx362_pos, 4
-    set_addr $I10, rxcap_367_fail
-    ($I12, $I11) = rx362_cur."!mark_peek"($I10)
-    rx362_cur."!cursor_pos"($I11)
-    ($P10) = rx362_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx362_pos, "")
-    rx362_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx339_pos, 4
+    gt $I11, rx339_eos, rx339_fail
+    sub $I11, rx339_pos, rx339_off
+    substr $S10, rx339_tgt, $I11, 4
+    ne $S10, "INIT", rx339_fail
+    add rx339_pos, 4
+    set_addr $I10, rxcap_344_fail
+    ($I12, $I11) = rx339_cur."!mark_peek"($I10)
+    rx339_cur."!cursor_pos"($I11)
+    ($P10) = rx339_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx339_pos, "")
+    rx339_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_367_done
-  rxcap_367_fail:
-    goto rx362_fail
-  rxcap_367_done:
+    goto rxcap_344_done
+  rxcap_344_fail:
+    goto rx339_fail
+  rxcap_344_done:
   # rx subrule "blorst" subtype=capture negate=
-    rx362_cur."!cursor_pos"(rx362_pos)
-    $P10 = rx362_cur."blorst"()
-    unless $P10, rx362_fail
-    rx362_cur."!mark_push"(0, -1, 0, $P10)
+    rx339_cur."!cursor_pos"(rx339_pos)
+    $P10 = rx339_cur."blorst"()
+    unless $P10, rx339_fail
+    rx339_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blorst")
-    rx362_pos = $P10."pos"()
+    rx339_pos = $P10."pos"()
   # rx pass
-    rx362_cur."!cursor_pass"(rx362_pos, "statement_prefix:sym<INIT>")
-    rx362_cur."!cursor_debug"("PASS  ", "statement_prefix:sym<INIT>", " at pos=", rx362_pos)
-    .return (rx362_cur)
-  rx362_fail:
+    rx339_cur."!cursor_pass"(rx339_pos, "statement_prefix:sym<INIT>")
+    rx339_cur."!cursor_debug"("PASS  ", "statement_prefix:sym<INIT>", " at pos=", rx339_pos)
+    .return (rx339_cur)
+  rx339_restart:
 .annotate 'line', 4
-    (rx362_rep, rx362_pos, $I10, $P10) = rx362_cur."!mark_fail"(0)
-    lt rx362_pos, -1, rx362_done
-    eq rx362_pos, -1, rx362_fail
+    rx339_cur."!cursor_debug"("NEXT ", "statement_prefix:sym<INIT>")
+  rx339_fail:
+    (rx339_rep, rx339_pos, $I10, $P10) = rx339_cur."!mark_fail"(0)
+    lt rx339_pos, -1, rx339_done
+    eq rx339_pos, -1, rx339_fail
     jump $I10
-  rx362_done:
-    rx362_cur."!cursor_fail"()
-    rx362_cur."!cursor_debug"("FAIL  ", "statement_prefix:sym<INIT>")
-    .return (rx362_cur)
+  rx339_done:
+    rx339_cur."!cursor_fail"()
+    rx339_cur."!cursor_debug"("FAIL  ", "statement_prefix:sym<INIT>")
+    .return (rx339_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_prefix:sym<INIT>"  :subid("80_1278500537.15927") :method
+.sub "!PREFIX__statement_prefix:sym<INIT>"  :subid("80_1279529226.73787") :method
 .annotate 'line', 4
-    $P364 = self."!PREFIX__!subrule"("blorst", "INIT")
-    new $P365, "ResizablePMCArray"
-    push $P365, $P364
-    .return ($P365)
+    $P341 = self."!PREFIX__!subrule"("blorst", "INIT")
+    new $P342, "ResizablePMCArray"
+    push $P342, $P341
+    .return ($P342)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_prefix:sym<try>"  :subid("81_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_prefix:sym<try>"  :subid("81_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx369_tgt
-    .local int rx369_pos
-    .local int rx369_off
-    .local int rx369_eos
-    .local int rx369_rep
-    .local pmc rx369_cur
-    (rx369_cur, rx369_pos, rx369_tgt) = self."!cursor_start"()
-    rx369_cur."!cursor_debug"("START ", "statement_prefix:sym<try>")
-    .lex unicode:"$\x{a2}", rx369_cur
+    .local string rx346_tgt
+    .local int rx346_pos
+    .local int rx346_off
+    .local int rx346_eos
+    .local int rx346_rep
+    .local pmc rx346_cur
+    (rx346_cur, rx346_pos, rx346_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx346_cur
     .local pmc match
     .lex "$/", match
-    length rx369_eos, rx369_tgt
-    gt rx369_pos, rx369_eos, rx369_done
-    set rx369_off, 0
-    lt rx369_pos, 2, rx369_start
-    sub rx369_off, rx369_pos, 1
-    substr rx369_tgt, rx369_tgt, rx369_off
-  rx369_start:
+    length rx346_eos, rx346_tgt
+    gt rx346_pos, rx346_eos, rx346_done
+    set rx346_off, 0
+    lt rx346_pos, 2, rx346_start
+    sub rx346_off, rx346_pos, 1
+    substr rx346_tgt, rx346_tgt, rx346_off
+  rx346_start:
+    eq $I10, 1, rx346_restart
+    rx346_cur."!cursor_debug"("START ", "statement_prefix:sym<try>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan373_done
-    goto rxscan373_scan
-  rxscan373_loop:
-    ($P10) = rx369_cur."from"()
+    ne $I10, -1, rxscan350_done
+    goto rxscan350_scan
+  rxscan350_loop:
+    ($P10) = rx346_cur."from"()
     inc $P10
-    set rx369_pos, $P10
-    ge rx369_pos, rx369_eos, rxscan373_done
-  rxscan373_scan:
-    set_addr $I10, rxscan373_loop
-    rx369_cur."!mark_push"(0, rx369_pos, $I10)
-  rxscan373_done:
+    set rx346_pos, $P10
+    ge rx346_pos, rx346_eos, rxscan350_done
+  rxscan350_scan:
+    set_addr $I10, rxscan350_loop
+    rx346_cur."!mark_push"(0, rx346_pos, $I10)
+  rxscan350_done:
 .annotate 'line', 202
   # rx subcapture "sym"
-    set_addr $I10, rxcap_374_fail
-    rx369_cur."!mark_push"(0, rx369_pos, $I10)
+    set_addr $I10, rxcap_351_fail
+    rx346_cur."!mark_push"(0, rx346_pos, $I10)
   # rx literal  "try"
-    add $I11, rx369_pos, 3
-    gt $I11, rx369_eos, rx369_fail
-    sub $I11, rx369_pos, rx369_off
-    substr $S10, rx369_tgt, $I11, 3
-    ne $S10, "try", rx369_fail
-    add rx369_pos, 3
-    set_addr $I10, rxcap_374_fail
-    ($I12, $I11) = rx369_cur."!mark_peek"($I10)
-    rx369_cur."!cursor_pos"($I11)
-    ($P10) = rx369_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx369_pos, "")
-    rx369_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx346_pos, 3
+    gt $I11, rx346_eos, rx346_fail
+    sub $I11, rx346_pos, rx346_off
+    substr $S10, rx346_tgt, $I11, 3
+    ne $S10, "try", rx346_fail
+    add rx346_pos, 3
+    set_addr $I10, rxcap_351_fail
+    ($I12, $I11) = rx346_cur."!mark_peek"($I10)
+    rx346_cur."!cursor_pos"($I11)
+    ($P10) = rx346_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx346_pos, "")
+    rx346_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_374_done
-  rxcap_374_fail:
-    goto rx369_fail
-  rxcap_374_done:
+    goto rxcap_351_done
+  rxcap_351_fail:
+    goto rx346_fail
+  rxcap_351_done:
 .annotate 'line', 203
   # rx subrule "blorst" subtype=capture negate=
-    rx369_cur."!cursor_pos"(rx369_pos)
-    $P10 = rx369_cur."blorst"()
-    unless $P10, rx369_fail
-    rx369_cur."!mark_push"(0, -1, 0, $P10)
+    rx346_cur."!cursor_pos"(rx346_pos)
+    $P10 = rx346_cur."blorst"()
+    unless $P10, rx346_fail
+    rx346_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blorst")
-    rx369_pos = $P10."pos"()
+    rx346_pos = $P10."pos"()
 .annotate 'line', 201
   # rx pass
-    rx369_cur."!cursor_pass"(rx369_pos, "statement_prefix:sym<try>")
-    rx369_cur."!cursor_debug"("PASS  ", "statement_prefix:sym<try>", " at pos=", rx369_pos)
-    .return (rx369_cur)
-  rx369_fail:
+    rx346_cur."!cursor_pass"(rx346_pos, "statement_prefix:sym<try>")
+    rx346_cur."!cursor_debug"("PASS  ", "statement_prefix:sym<try>", " at pos=", rx346_pos)
+    .return (rx346_cur)
+  rx346_restart:
 .annotate 'line', 4
-    (rx369_rep, rx369_pos, $I10, $P10) = rx369_cur."!mark_fail"(0)
-    lt rx369_pos, -1, rx369_done
-    eq rx369_pos, -1, rx369_fail
+    rx346_cur."!cursor_debug"("NEXT ", "statement_prefix:sym<try>")
+  rx346_fail:
+    (rx346_rep, rx346_pos, $I10, $P10) = rx346_cur."!mark_fail"(0)
+    lt rx346_pos, -1, rx346_done
+    eq rx346_pos, -1, rx346_fail
     jump $I10
-  rx369_done:
-    rx369_cur."!cursor_fail"()
-    rx369_cur."!cursor_debug"("FAIL  ", "statement_prefix:sym<try>")
-    .return (rx369_cur)
+  rx346_done:
+    rx346_cur."!cursor_fail"()
+    rx346_cur."!cursor_debug"("FAIL  ", "statement_prefix:sym<try>")
+    .return (rx346_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_prefix:sym<try>"  :subid("82_1278500537.15927") :method
+.sub "!PREFIX__statement_prefix:sym<try>"  :subid("82_1279529226.73787") :method
 .annotate 'line', 4
-    $P371 = self."!PREFIX__!subrule"("blorst", "try")
-    new $P372, "ResizablePMCArray"
-    push $P372, $P371
-    .return ($P372)
+    $P348 = self."!PREFIX__!subrule"("blorst", "try")
+    new $P349, "ResizablePMCArray"
+    push $P349, $P348
+    .return ($P349)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "blorst"  :subid("83_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "blorst"  :subid("83_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx376_tgt
-    .local int rx376_pos
-    .local int rx376_off
-    .local int rx376_eos
-    .local int rx376_rep
-    .local pmc rx376_cur
-    (rx376_cur, rx376_pos, rx376_tgt) = self."!cursor_start"()
-    rx376_cur."!cursor_debug"("START ", "blorst")
-    .lex unicode:"$\x{a2}", rx376_cur
+    .local string rx353_tgt
+    .local int rx353_pos
+    .local int rx353_off
+    .local int rx353_eos
+    .local int rx353_rep
+    .local pmc rx353_cur
+    (rx353_cur, rx353_pos, rx353_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx353_cur
     .local pmc match
     .lex "$/", match
-    length rx376_eos, rx376_tgt
-    gt rx376_pos, rx376_eos, rx376_done
-    set rx376_off, 0
-    lt rx376_pos, 2, rx376_start
-    sub rx376_off, rx376_pos, 1
-    substr rx376_tgt, rx376_tgt, rx376_off
-  rx376_start:
+    length rx353_eos, rx353_tgt
+    gt rx353_pos, rx353_eos, rx353_done
+    set rx353_off, 0
+    lt rx353_pos, 2, rx353_start
+    sub rx353_off, rx353_pos, 1
+    substr rx353_tgt, rx353_tgt, rx353_off
+  rx353_start:
+    eq $I10, 1, rx353_restart
+    rx353_cur."!cursor_debug"("START ", "blorst")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan379_done
-    goto rxscan379_scan
-  rxscan379_loop:
-    ($P10) = rx376_cur."from"()
+    ne $I10, -1, rxscan356_done
+    goto rxscan356_scan
+  rxscan356_loop:
+    ($P10) = rx353_cur."from"()
     inc $P10
-    set rx376_pos, $P10
-    ge rx376_pos, rx376_eos, rxscan379_done
-  rxscan379_scan:
-    set_addr $I10, rxscan379_loop
-    rx376_cur."!mark_push"(0, rx376_pos, $I10)
-  rxscan379_done:
+    set rx353_pos, $P10
+    ge rx353_pos, rx353_eos, rxscan356_done
+  rxscan356_scan:
+    set_addr $I10, rxscan356_loop
+    rx353_cur."!mark_push"(0, rx353_pos, $I10)
+  rxscan356_done:
 .annotate 'line', 207
   # rx charclass s
-    ge rx376_pos, rx376_eos, rx376_fail
-    sub $I10, rx376_pos, rx376_off
-    is_cclass $I11, 32, rx376_tgt, $I10
-    unless $I11, rx376_fail
-    inc rx376_pos
-  # rx subrule "ws" subtype=method negate=
-    rx376_cur."!cursor_pos"(rx376_pos)
-    $P10 = rx376_cur."ws"()
-    unless $P10, rx376_fail
-    rx376_pos = $P10."pos"()
-  alt380_0:
-    set_addr $I10, alt380_1
-    rx376_cur."!mark_push"(0, rx376_pos, $I10)
+    ge rx353_pos, rx353_eos, rx353_fail
+    sub $I10, rx353_pos, rx353_off
+    is_cclass $I11, 32, rx353_tgt, $I10
+    unless $I11, rx353_fail
+    inc rx353_pos
+  # rx subrule "ws" subtype=method negate=
+    rx353_cur."!cursor_pos"(rx353_pos)
+    $P10 = rx353_cur."ws"()
+    unless $P10, rx353_fail
+    rx353_pos = $P10."pos"()
+  alt357_0:
+    set_addr $I10, alt357_1
+    rx353_cur."!mark_push"(0, rx353_pos, $I10)
   # rx enumcharlist negate=0 zerowidth
-    ge rx376_pos, rx376_eos, rx376_fail
-    sub $I10, rx376_pos, rx376_off
-    substr $S10, rx376_tgt, $I10, 1
+    ge rx353_pos, rx353_eos, rx353_fail
+    sub $I10, rx353_pos, rx353_off
+    substr $S10, rx353_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx376_fail
+    lt $I11, 0, rx353_fail
   # rx subrule "block" subtype=capture negate=
-    rx376_cur."!cursor_pos"(rx376_pos)
-    $P10 = rx376_cur."block"()
-    unless $P10, rx376_fail
-    rx376_cur."!mark_push"(0, -1, 0, $P10)
+    rx353_cur."!cursor_pos"(rx353_pos)
+    $P10 = rx353_cur."block"()
+    unless $P10, rx353_fail
+    rx353_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("block")
-    rx376_pos = $P10."pos"()
-    goto alt380_end
-  alt380_1:
+    rx353_pos = $P10."pos"()
+    goto alt357_end
+  alt357_1:
   # rx subrule "statement" subtype=capture negate=
-    rx376_cur."!cursor_pos"(rx376_pos)
-    $P10 = rx376_cur."statement"()
-    unless $P10, rx376_fail
-    rx376_cur."!mark_push"(0, -1, 0, $P10)
+    rx353_cur."!cursor_pos"(rx353_pos)
+    $P10 = rx353_cur."statement"()
+    unless $P10, rx353_fail
+    rx353_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("statement")
-    rx376_pos = $P10."pos"()
-  alt380_end:
+    rx353_pos = $P10."pos"()
+  alt357_end:
 .annotate 'line', 206
   # rx pass
-    rx376_cur."!cursor_pass"(rx376_pos, "blorst")
-    rx376_cur."!cursor_debug"("PASS  ", "blorst", " at pos=", rx376_pos)
-    .return (rx376_cur)
-  rx376_fail:
+    rx353_cur."!cursor_pass"(rx353_pos, "blorst")
+    rx353_cur."!cursor_debug"("PASS  ", "blorst", " at pos=", rx353_pos)
+    .return (rx353_cur)
+  rx353_restart:
 .annotate 'line', 4
-    (rx376_rep, rx376_pos, $I10, $P10) = rx376_cur."!mark_fail"(0)
-    lt rx376_pos, -1, rx376_done
-    eq rx376_pos, -1, rx376_fail
+    rx353_cur."!cursor_debug"("NEXT ", "blorst")
+  rx353_fail:
+    (rx353_rep, rx353_pos, $I10, $P10) = rx353_cur."!mark_fail"(0)
+    lt rx353_pos, -1, rx353_done
+    eq rx353_pos, -1, rx353_fail
     jump $I10
-  rx376_done:
-    rx376_cur."!cursor_fail"()
-    rx376_cur."!cursor_debug"("FAIL  ", "blorst")
-    .return (rx376_cur)
+  rx353_done:
+    rx353_cur."!cursor_fail"()
+    rx353_cur."!cursor_debug"("FAIL  ", "blorst")
+    .return (rx353_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__blorst"  :subid("84_1278500537.15927") :method
+.sub "!PREFIX__blorst"  :subid("84_1279529226.73787") :method
 .annotate 'line', 4
-    new $P378, "ResizablePMCArray"
-    push $P378, ""
-    .return ($P378)
+    new $P355, "ResizablePMCArray"
+    push $P355, ""
+    .return ($P355)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_cond"  :subid("85_1278500537.15927") :method
+.sub "statement_mod_cond"  :subid("85_1279529226.73787") :method
 .annotate 'line', 212
-    $P382 = self."!protoregex"("statement_mod_cond")
-    .return ($P382)
+    $P359 = self."!protoregex"("statement_mod_cond")
+    .return ($P359)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_cond"  :subid("86_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_cond"  :subid("86_1279529226.73787") :method
 .annotate 'line', 212
-    $P384 = self."!PREFIX__!protoregex"("statement_mod_cond")
-    .return ($P384)
+    $P361 = self."!PREFIX__!protoregex"("statement_mod_cond")
+    .return ($P361)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_cond:sym<if>"  :subid("87_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_mod_cond:sym<if>"  :subid("87_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx386_tgt
-    .local int rx386_pos
-    .local int rx386_off
-    .local int rx386_eos
-    .local int rx386_rep
-    .local pmc rx386_cur
-    (rx386_cur, rx386_pos, rx386_tgt) = self."!cursor_start"()
-    rx386_cur."!cursor_debug"("START ", "statement_mod_cond:sym<if>")
-    .lex unicode:"$\x{a2}", rx386_cur
-    .local pmc match
-    .lex "$/", match
-    length rx386_eos, rx386_tgt
-    gt rx386_pos, rx386_eos, rx386_done
-    set rx386_off, 0
-    lt rx386_pos, 2, rx386_start
-    sub rx386_off, rx386_pos, 1
-    substr rx386_tgt, rx386_tgt, rx386_off
-  rx386_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan390_done
-    goto rxscan390_scan
-  rxscan390_loop:
-    ($P10) = rx386_cur."from"()
-    inc $P10
-    set rx386_pos, $P10
-    ge rx386_pos, rx386_eos, rxscan390_done
-  rxscan390_scan:
-    set_addr $I10, rxscan390_loop
-    rx386_cur."!mark_push"(0, rx386_pos, $I10)
-  rxscan390_done:
+    .local string rx363_tgt
+    .local int rx363_pos
+    .local int rx363_off
+    .local int rx363_eos
+    .local int rx363_rep
+    .local pmc rx363_cur
+    (rx363_cur, rx363_pos, rx363_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx363_cur
+    .local pmc match
+    .lex "$/", match
+    length rx363_eos, rx363_tgt
+    gt rx363_pos, rx363_eos, rx363_done
+    set rx363_off, 0
+    lt rx363_pos, 2, rx363_start
+    sub rx363_off, rx363_pos, 1
+    substr rx363_tgt, rx363_tgt, rx363_off
+  rx363_start:
+    eq $I10, 1, rx363_restart
+    rx363_cur."!cursor_debug"("START ", "statement_mod_cond:sym<if>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan367_done
+    goto rxscan367_scan
+  rxscan367_loop:
+    ($P10) = rx363_cur."from"()
+    inc $P10
+    set rx363_pos, $P10
+    ge rx363_pos, rx363_eos, rxscan367_done
+  rxscan367_scan:
+    set_addr $I10, rxscan367_loop
+    rx363_cur."!mark_push"(0, rx363_pos, $I10)
+  rxscan367_done:
 .annotate 'line', 214
   # rx subcapture "sym"
-    set_addr $I10, rxcap_391_fail
-    rx386_cur."!mark_push"(0, rx386_pos, $I10)
+    set_addr $I10, rxcap_368_fail
+    rx363_cur."!mark_push"(0, rx363_pos, $I10)
   # rx literal  "if"
-    add $I11, rx386_pos, 2
-    gt $I11, rx386_eos, rx386_fail
-    sub $I11, rx386_pos, rx386_off
-    substr $S10, rx386_tgt, $I11, 2
-    ne $S10, "if", rx386_fail
-    add rx386_pos, 2
-    set_addr $I10, rxcap_391_fail
-    ($I12, $I11) = rx386_cur."!mark_peek"($I10)
-    rx386_cur."!cursor_pos"($I11)
-    ($P10) = rx386_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx386_pos, "")
-    rx386_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx363_pos, 2
+    gt $I11, rx363_eos, rx363_fail
+    sub $I11, rx363_pos, rx363_off
+    substr $S10, rx363_tgt, $I11, 2
+    ne $S10, "if", rx363_fail
+    add rx363_pos, 2
+    set_addr $I10, rxcap_368_fail
+    ($I12, $I11) = rx363_cur."!mark_peek"($I10)
+    rx363_cur."!cursor_pos"($I11)
+    ($P10) = rx363_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx363_pos, "")
+    rx363_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_391_done
-  rxcap_391_fail:
-    goto rx386_fail
-  rxcap_391_done:
-  # rx subrule "ws" subtype=method negate=
-    rx386_cur."!cursor_pos"(rx386_pos)
-    $P10 = rx386_cur."ws"()
-    unless $P10, rx386_fail
-    rx386_pos = $P10."pos"()
+    goto rxcap_368_done
+  rxcap_368_fail:
+    goto rx363_fail
+  rxcap_368_done:
+  # rx subrule "ws" subtype=method negate=
+    rx363_cur."!cursor_pos"(rx363_pos)
+    $P10 = rx363_cur."ws"()
+    unless $P10, rx363_fail
+    rx363_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx386_cur."!cursor_pos"(rx386_pos)
-    $P10 = rx386_cur."EXPR"()
-    unless $P10, rx386_fail
-    rx386_cur."!mark_push"(0, -1, 0, $P10)
+    rx363_cur."!cursor_pos"(rx363_pos)
+    $P10 = rx363_cur."EXPR"()
+    unless $P10, rx363_fail
+    rx363_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("cond")
-    rx386_pos = $P10."pos"()
+    rx363_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx386_cur."!cursor_pos"(rx386_pos)
-    $P10 = rx386_cur."ws"()
-    unless $P10, rx386_fail
-    rx386_pos = $P10."pos"()
+    rx363_cur."!cursor_pos"(rx363_pos)
+    $P10 = rx363_cur."ws"()
+    unless $P10, rx363_fail
+    rx363_pos = $P10."pos"()
   # rx pass
-    rx386_cur."!cursor_pass"(rx386_pos, "statement_mod_cond:sym<if>")
-    rx386_cur."!cursor_debug"("PASS  ", "statement_mod_cond:sym<if>", " at pos=", rx386_pos)
-    .return (rx386_cur)
-  rx386_fail:
+    rx363_cur."!cursor_pass"(rx363_pos, "statement_mod_cond:sym<if>")
+    rx363_cur."!cursor_debug"("PASS  ", "statement_mod_cond:sym<if>", " at pos=", rx363_pos)
+    .return (rx363_cur)
+  rx363_restart:
 .annotate 'line', 4
-    (rx386_rep, rx386_pos, $I10, $P10) = rx386_cur."!mark_fail"(0)
-    lt rx386_pos, -1, rx386_done
-    eq rx386_pos, -1, rx386_fail
+    rx363_cur."!cursor_debug"("NEXT ", "statement_mod_cond:sym<if>")
+  rx363_fail:
+    (rx363_rep, rx363_pos, $I10, $P10) = rx363_cur."!mark_fail"(0)
+    lt rx363_pos, -1, rx363_done
+    eq rx363_pos, -1, rx363_fail
     jump $I10
-  rx386_done:
-    rx386_cur."!cursor_fail"()
-    rx386_cur."!cursor_debug"("FAIL  ", "statement_mod_cond:sym<if>")
-    .return (rx386_cur)
+  rx363_done:
+    rx363_cur."!cursor_fail"()
+    rx363_cur."!cursor_debug"("FAIL  ", "statement_mod_cond:sym<if>")
+    .return (rx363_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_cond:sym<if>"  :subid("88_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_cond:sym<if>"  :subid("88_1279529226.73787") :method
 .annotate 'line', 4
-    $P388 = self."!PREFIX__!subrule"("ws", "if")
-    new $P389, "ResizablePMCArray"
-    push $P389, $P388
-    .return ($P389)
+    $P365 = self."!PREFIX__!subrule"("ws", "if")
+    new $P366, "ResizablePMCArray"
+    push $P366, $P365
+    .return ($P366)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_cond:sym<unless>"  :subid("89_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_mod_cond:sym<unless>"  :subid("89_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx395_tgt
-    .local int rx395_pos
-    .local int rx395_off
-    .local int rx395_eos
-    .local int rx395_rep
-    .local pmc rx395_cur
-    (rx395_cur, rx395_pos, rx395_tgt) = self."!cursor_start"()
-    rx395_cur."!cursor_debug"("START ", "statement_mod_cond:sym<unless>")
-    .lex unicode:"$\x{a2}", rx395_cur
+    .local string rx372_tgt
+    .local int rx372_pos
+    .local int rx372_off
+    .local int rx372_eos
+    .local int rx372_rep
+    .local pmc rx372_cur
+    (rx372_cur, rx372_pos, rx372_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx372_cur
     .local pmc match
     .lex "$/", match
-    length rx395_eos, rx395_tgt
-    gt rx395_pos, rx395_eos, rx395_done
-    set rx395_off, 0
-    lt rx395_pos, 2, rx395_start
-    sub rx395_off, rx395_pos, 1
-    substr rx395_tgt, rx395_tgt, rx395_off
-  rx395_start:
+    length rx372_eos, rx372_tgt
+    gt rx372_pos, rx372_eos, rx372_done
+    set rx372_off, 0
+    lt rx372_pos, 2, rx372_start
+    sub rx372_off, rx372_pos, 1
+    substr rx372_tgt, rx372_tgt, rx372_off
+  rx372_start:
+    eq $I10, 1, rx372_restart
+    rx372_cur."!cursor_debug"("START ", "statement_mod_cond:sym<unless>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan399_done
-    goto rxscan399_scan
-  rxscan399_loop:
-    ($P10) = rx395_cur."from"()
+    ne $I10, -1, rxscan376_done
+    goto rxscan376_scan
+  rxscan376_loop:
+    ($P10) = rx372_cur."from"()
     inc $P10
-    set rx395_pos, $P10
-    ge rx395_pos, rx395_eos, rxscan399_done
-  rxscan399_scan:
-    set_addr $I10, rxscan399_loop
-    rx395_cur."!mark_push"(0, rx395_pos, $I10)
-  rxscan399_done:
+    set rx372_pos, $P10
+    ge rx372_pos, rx372_eos, rxscan376_done
+  rxscan376_scan:
+    set_addr $I10, rxscan376_loop
+    rx372_cur."!mark_push"(0, rx372_pos, $I10)
+  rxscan376_done:
 .annotate 'line', 215
   # rx subcapture "sym"
-    set_addr $I10, rxcap_400_fail
-    rx395_cur."!mark_push"(0, rx395_pos, $I10)
+    set_addr $I10, rxcap_377_fail
+    rx372_cur."!mark_push"(0, rx372_pos, $I10)
   # rx literal  "unless"
-    add $I11, rx395_pos, 6
-    gt $I11, rx395_eos, rx395_fail
-    sub $I11, rx395_pos, rx395_off
-    substr $S10, rx395_tgt, $I11, 6
-    ne $S10, "unless", rx395_fail
-    add rx395_pos, 6
-    set_addr $I10, rxcap_400_fail
-    ($I12, $I11) = rx395_cur."!mark_peek"($I10)
-    rx395_cur."!cursor_pos"($I11)
-    ($P10) = rx395_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx395_pos, "")
-    rx395_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx372_pos, 6
+    gt $I11, rx372_eos, rx372_fail
+    sub $I11, rx372_pos, rx372_off
+    substr $S10, rx372_tgt, $I11, 6
+    ne $S10, "unless", rx372_fail
+    add rx372_pos, 6
+    set_addr $I10, rxcap_377_fail
+    ($I12, $I11) = rx372_cur."!mark_peek"($I10)
+    rx372_cur."!cursor_pos"($I11)
+    ($P10) = rx372_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx372_pos, "")
+    rx372_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_400_done
-  rxcap_400_fail:
-    goto rx395_fail
-  rxcap_400_done:
-  # rx subrule "ws" subtype=method negate=
-    rx395_cur."!cursor_pos"(rx395_pos)
-    $P10 = rx395_cur."ws"()
-    unless $P10, rx395_fail
-    rx395_pos = $P10."pos"()
+    goto rxcap_377_done
+  rxcap_377_fail:
+    goto rx372_fail
+  rxcap_377_done:
+  # rx subrule "ws" subtype=method negate=
+    rx372_cur."!cursor_pos"(rx372_pos)
+    $P10 = rx372_cur."ws"()
+    unless $P10, rx372_fail
+    rx372_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx395_cur."!cursor_pos"(rx395_pos)
-    $P10 = rx395_cur."EXPR"()
-    unless $P10, rx395_fail
-    rx395_cur."!mark_push"(0, -1, 0, $P10)
+    rx372_cur."!cursor_pos"(rx372_pos)
+    $P10 = rx372_cur."EXPR"()
+    unless $P10, rx372_fail
+    rx372_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("cond")
-    rx395_pos = $P10."pos"()
+    rx372_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx395_cur."!cursor_pos"(rx395_pos)
-    $P10 = rx395_cur."ws"()
-    unless $P10, rx395_fail
-    rx395_pos = $P10."pos"()
+    rx372_cur."!cursor_pos"(rx372_pos)
+    $P10 = rx372_cur."ws"()
+    unless $P10, rx372_fail
+    rx372_pos = $P10."pos"()
   # rx pass
-    rx395_cur."!cursor_pass"(rx395_pos, "statement_mod_cond:sym<unless>")
-    rx395_cur."!cursor_debug"("PASS  ", "statement_mod_cond:sym<unless>", " at pos=", rx395_pos)
-    .return (rx395_cur)
-  rx395_fail:
+    rx372_cur."!cursor_pass"(rx372_pos, "statement_mod_cond:sym<unless>")
+    rx372_cur."!cursor_debug"("PASS  ", "statement_mod_cond:sym<unless>", " at pos=", rx372_pos)
+    .return (rx372_cur)
+  rx372_restart:
 .annotate 'line', 4
-    (rx395_rep, rx395_pos, $I10, $P10) = rx395_cur."!mark_fail"(0)
-    lt rx395_pos, -1, rx395_done
-    eq rx395_pos, -1, rx395_fail
+    rx372_cur."!cursor_debug"("NEXT ", "statement_mod_cond:sym<unless>")
+  rx372_fail:
+    (rx372_rep, rx372_pos, $I10, $P10) = rx372_cur."!mark_fail"(0)
+    lt rx372_pos, -1, rx372_done
+    eq rx372_pos, -1, rx372_fail
     jump $I10
-  rx395_done:
-    rx395_cur."!cursor_fail"()
-    rx395_cur."!cursor_debug"("FAIL  ", "statement_mod_cond:sym<unless>")
-    .return (rx395_cur)
+  rx372_done:
+    rx372_cur."!cursor_fail"()
+    rx372_cur."!cursor_debug"("FAIL  ", "statement_mod_cond:sym<unless>")
+    .return (rx372_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_cond:sym<unless>"  :subid("90_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_cond:sym<unless>"  :subid("90_1279529226.73787") :method
 .annotate 'line', 4
-    $P397 = self."!PREFIX__!subrule"("ws", "unless")
-    new $P398, "ResizablePMCArray"
-    push $P398, $P397
-    .return ($P398)
+    $P374 = self."!PREFIX__!subrule"("ws", "unless")
+    new $P375, "ResizablePMCArray"
+    push $P375, $P374
+    .return ($P375)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_loop"  :subid("91_1278500537.15927") :method
+.sub "statement_mod_loop"  :subid("91_1279529226.73787") :method
 .annotate 'line', 217
-    $P404 = self."!protoregex"("statement_mod_loop")
-    .return ($P404)
+    $P381 = self."!protoregex"("statement_mod_loop")
+    .return ($P381)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_loop"  :subid("92_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_loop"  :subid("92_1279529226.73787") :method
 .annotate 'line', 217
-    $P406 = self."!PREFIX__!protoregex"("statement_mod_loop")
-    .return ($P406)
+    $P383 = self."!PREFIX__!protoregex"("statement_mod_loop")
+    .return ($P383)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_loop:sym<while>"  :subid("93_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_mod_loop:sym<while>"  :subid("93_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx408_tgt
-    .local int rx408_pos
-    .local int rx408_off
-    .local int rx408_eos
-    .local int rx408_rep
-    .local pmc rx408_cur
-    (rx408_cur, rx408_pos, rx408_tgt) = self."!cursor_start"()
-    rx408_cur."!cursor_debug"("START ", "statement_mod_loop:sym<while>")
-    .lex unicode:"$\x{a2}", rx408_cur
-    .local pmc match
-    .lex "$/", match
-    length rx408_eos, rx408_tgt
-    gt rx408_pos, rx408_eos, rx408_done
-    set rx408_off, 0
-    lt rx408_pos, 2, rx408_start
-    sub rx408_off, rx408_pos, 1
-    substr rx408_tgt, rx408_tgt, rx408_off
-  rx408_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan412_done
-    goto rxscan412_scan
-  rxscan412_loop:
-    ($P10) = rx408_cur."from"()
-    inc $P10
-    set rx408_pos, $P10
-    ge rx408_pos, rx408_eos, rxscan412_done
-  rxscan412_scan:
-    set_addr $I10, rxscan412_loop
-    rx408_cur."!mark_push"(0, rx408_pos, $I10)
-  rxscan412_done:
+    .local string rx385_tgt
+    .local int rx385_pos
+    .local int rx385_off
+    .local int rx385_eos
+    .local int rx385_rep
+    .local pmc rx385_cur
+    (rx385_cur, rx385_pos, rx385_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx385_cur
+    .local pmc match
+    .lex "$/", match
+    length rx385_eos, rx385_tgt
+    gt rx385_pos, rx385_eos, rx385_done
+    set rx385_off, 0
+    lt rx385_pos, 2, rx385_start
+    sub rx385_off, rx385_pos, 1
+    substr rx385_tgt, rx385_tgt, rx385_off
+  rx385_start:
+    eq $I10, 1, rx385_restart
+    rx385_cur."!cursor_debug"("START ", "statement_mod_loop:sym<while>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan389_done
+    goto rxscan389_scan
+  rxscan389_loop:
+    ($P10) = rx385_cur."from"()
+    inc $P10
+    set rx385_pos, $P10
+    ge rx385_pos, rx385_eos, rxscan389_done
+  rxscan389_scan:
+    set_addr $I10, rxscan389_loop
+    rx385_cur."!mark_push"(0, rx385_pos, $I10)
+  rxscan389_done:
 .annotate 'line', 219
   # rx subcapture "sym"
-    set_addr $I10, rxcap_413_fail
-    rx408_cur."!mark_push"(0, rx408_pos, $I10)
+    set_addr $I10, rxcap_390_fail
+    rx385_cur."!mark_push"(0, rx385_pos, $I10)
   # rx literal  "while"
-    add $I11, rx408_pos, 5
-    gt $I11, rx408_eos, rx408_fail
-    sub $I11, rx408_pos, rx408_off
-    substr $S10, rx408_tgt, $I11, 5
-    ne $S10, "while", rx408_fail
-    add rx408_pos, 5
-    set_addr $I10, rxcap_413_fail
-    ($I12, $I11) = rx408_cur."!mark_peek"($I10)
-    rx408_cur."!cursor_pos"($I11)
-    ($P10) = rx408_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx408_pos, "")
-    rx408_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx385_pos, 5
+    gt $I11, rx385_eos, rx385_fail
+    sub $I11, rx385_pos, rx385_off
+    substr $S10, rx385_tgt, $I11, 5
+    ne $S10, "while", rx385_fail
+    add rx385_pos, 5
+    set_addr $I10, rxcap_390_fail
+    ($I12, $I11) = rx385_cur."!mark_peek"($I10)
+    rx385_cur."!cursor_pos"($I11)
+    ($P10) = rx385_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx385_pos, "")
+    rx385_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_413_done
-  rxcap_413_fail:
-    goto rx408_fail
-  rxcap_413_done:
-  # rx subrule "ws" subtype=method negate=
-    rx408_cur."!cursor_pos"(rx408_pos)
-    $P10 = rx408_cur."ws"()
-    unless $P10, rx408_fail
-    rx408_pos = $P10."pos"()
+    goto rxcap_390_done
+  rxcap_390_fail:
+    goto rx385_fail
+  rxcap_390_done:
+  # rx subrule "ws" subtype=method negate=
+    rx385_cur."!cursor_pos"(rx385_pos)
+    $P10 = rx385_cur."ws"()
+    unless $P10, rx385_fail
+    rx385_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx408_cur."!cursor_pos"(rx408_pos)
-    $P10 = rx408_cur."EXPR"()
-    unless $P10, rx408_fail
-    rx408_cur."!mark_push"(0, -1, 0, $P10)
+    rx385_cur."!cursor_pos"(rx385_pos)
+    $P10 = rx385_cur."EXPR"()
+    unless $P10, rx385_fail
+    rx385_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("cond")
-    rx408_pos = $P10."pos"()
+    rx385_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx408_cur."!cursor_pos"(rx408_pos)
-    $P10 = rx408_cur."ws"()
-    unless $P10, rx408_fail
-    rx408_pos = $P10."pos"()
+    rx385_cur."!cursor_pos"(rx385_pos)
+    $P10 = rx385_cur."ws"()
+    unless $P10, rx385_fail
+    rx385_pos = $P10."pos"()
   # rx pass
-    rx408_cur."!cursor_pass"(rx408_pos, "statement_mod_loop:sym<while>")
-    rx408_cur."!cursor_debug"("PASS  ", "statement_mod_loop:sym<while>", " at pos=", rx408_pos)
-    .return (rx408_cur)
-  rx408_fail:
+    rx385_cur."!cursor_pass"(rx385_pos, "statement_mod_loop:sym<while>")
+    rx385_cur."!cursor_debug"("PASS  ", "statement_mod_loop:sym<while>", " at pos=", rx385_pos)
+    .return (rx385_cur)
+  rx385_restart:
 .annotate 'line', 4
-    (rx408_rep, rx408_pos, $I10, $P10) = rx408_cur."!mark_fail"(0)
-    lt rx408_pos, -1, rx408_done
-    eq rx408_pos, -1, rx408_fail
+    rx385_cur."!cursor_debug"("NEXT ", "statement_mod_loop:sym<while>")
+  rx385_fail:
+    (rx385_rep, rx385_pos, $I10, $P10) = rx385_cur."!mark_fail"(0)
+    lt rx385_pos, -1, rx385_done
+    eq rx385_pos, -1, rx385_fail
     jump $I10
-  rx408_done:
-    rx408_cur."!cursor_fail"()
-    rx408_cur."!cursor_debug"("FAIL  ", "statement_mod_loop:sym<while>")
-    .return (rx408_cur)
+  rx385_done:
+    rx385_cur."!cursor_fail"()
+    rx385_cur."!cursor_debug"("FAIL  ", "statement_mod_loop:sym<while>")
+    .return (rx385_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_loop:sym<while>"  :subid("94_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_loop:sym<while>"  :subid("94_1279529226.73787") :method
 .annotate 'line', 4
-    $P410 = self."!PREFIX__!subrule"("ws", "while")
-    new $P411, "ResizablePMCArray"
-    push $P411, $P410
-    .return ($P411)
+    $P387 = self."!PREFIX__!subrule"("ws", "while")
+    new $P388, "ResizablePMCArray"
+    push $P388, $P387
+    .return ($P388)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_loop:sym<until>"  :subid("95_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_mod_loop:sym<until>"  :subid("95_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx417_tgt
-    .local int rx417_pos
-    .local int rx417_off
-    .local int rx417_eos
-    .local int rx417_rep
-    .local pmc rx417_cur
-    (rx417_cur, rx417_pos, rx417_tgt) = self."!cursor_start"()
-    rx417_cur."!cursor_debug"("START ", "statement_mod_loop:sym<until>")
-    .lex unicode:"$\x{a2}", rx417_cur
+    .local string rx394_tgt
+    .local int rx394_pos
+    .local int rx394_off
+    .local int rx394_eos
+    .local int rx394_rep
+    .local pmc rx394_cur
+    (rx394_cur, rx394_pos, rx394_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx394_cur
     .local pmc match
     .lex "$/", match
-    length rx417_eos, rx417_tgt
-    gt rx417_pos, rx417_eos, rx417_done
-    set rx417_off, 0
-    lt rx417_pos, 2, rx417_start
-    sub rx417_off, rx417_pos, 1
-    substr rx417_tgt, rx417_tgt, rx417_off
-  rx417_start:
+    length rx394_eos, rx394_tgt
+    gt rx394_pos, rx394_eos, rx394_done
+    set rx394_off, 0
+    lt rx394_pos, 2, rx394_start
+    sub rx394_off, rx394_pos, 1
+    substr rx394_tgt, rx394_tgt, rx394_off
+  rx394_start:
+    eq $I10, 1, rx394_restart
+    rx394_cur."!cursor_debug"("START ", "statement_mod_loop:sym<until>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan421_done
-    goto rxscan421_scan
-  rxscan421_loop:
-    ($P10) = rx417_cur."from"()
+    ne $I10, -1, rxscan398_done
+    goto rxscan398_scan
+  rxscan398_loop:
+    ($P10) = rx394_cur."from"()
     inc $P10
-    set rx417_pos, $P10
-    ge rx417_pos, rx417_eos, rxscan421_done
-  rxscan421_scan:
-    set_addr $I10, rxscan421_loop
-    rx417_cur."!mark_push"(0, rx417_pos, $I10)
-  rxscan421_done:
+    set rx394_pos, $P10
+    ge rx394_pos, rx394_eos, rxscan398_done
+  rxscan398_scan:
+    set_addr $I10, rxscan398_loop
+    rx394_cur."!mark_push"(0, rx394_pos, $I10)
+  rxscan398_done:
 .annotate 'line', 220
   # rx subcapture "sym"
-    set_addr $I10, rxcap_422_fail
-    rx417_cur."!mark_push"(0, rx417_pos, $I10)
+    set_addr $I10, rxcap_399_fail
+    rx394_cur."!mark_push"(0, rx394_pos, $I10)
   # rx literal  "until"
-    add $I11, rx417_pos, 5
-    gt $I11, rx417_eos, rx417_fail
-    sub $I11, rx417_pos, rx417_off
-    substr $S10, rx417_tgt, $I11, 5
-    ne $S10, "until", rx417_fail
-    add rx417_pos, 5
-    set_addr $I10, rxcap_422_fail
-    ($I12, $I11) = rx417_cur."!mark_peek"($I10)
-    rx417_cur."!cursor_pos"($I11)
-    ($P10) = rx417_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx417_pos, "")
-    rx417_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx394_pos, 5
+    gt $I11, rx394_eos, rx394_fail
+    sub $I11, rx394_pos, rx394_off
+    substr $S10, rx394_tgt, $I11, 5
+    ne $S10, "until", rx394_fail
+    add rx394_pos, 5
+    set_addr $I10, rxcap_399_fail
+    ($I12, $I11) = rx394_cur."!mark_peek"($I10)
+    rx394_cur."!cursor_pos"($I11)
+    ($P10) = rx394_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx394_pos, "")
+    rx394_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_422_done
-  rxcap_422_fail:
-    goto rx417_fail
-  rxcap_422_done:
-  # rx subrule "ws" subtype=method negate=
-    rx417_cur."!cursor_pos"(rx417_pos)
-    $P10 = rx417_cur."ws"()
-    unless $P10, rx417_fail
-    rx417_pos = $P10."pos"()
+    goto rxcap_399_done
+  rxcap_399_fail:
+    goto rx394_fail
+  rxcap_399_done:
+  # rx subrule "ws" subtype=method negate=
+    rx394_cur."!cursor_pos"(rx394_pos)
+    $P10 = rx394_cur."ws"()
+    unless $P10, rx394_fail
+    rx394_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx417_cur."!cursor_pos"(rx417_pos)
-    $P10 = rx417_cur."EXPR"()
-    unless $P10, rx417_fail
-    rx417_cur."!mark_push"(0, -1, 0, $P10)
+    rx394_cur."!cursor_pos"(rx394_pos)
+    $P10 = rx394_cur."EXPR"()
+    unless $P10, rx394_fail
+    rx394_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("cond")
-    rx417_pos = $P10."pos"()
+    rx394_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx417_cur."!cursor_pos"(rx417_pos)
-    $P10 = rx417_cur."ws"()
-    unless $P10, rx417_fail
-    rx417_pos = $P10."pos"()
+    rx394_cur."!cursor_pos"(rx394_pos)
+    $P10 = rx394_cur."ws"()
+    unless $P10, rx394_fail
+    rx394_pos = $P10."pos"()
   # rx pass
-    rx417_cur."!cursor_pass"(rx417_pos, "statement_mod_loop:sym<until>")
-    rx417_cur."!cursor_debug"("PASS  ", "statement_mod_loop:sym<until>", " at pos=", rx417_pos)
-    .return (rx417_cur)
-  rx417_fail:
+    rx394_cur."!cursor_pass"(rx394_pos, "statement_mod_loop:sym<until>")
+    rx394_cur."!cursor_debug"("PASS  ", "statement_mod_loop:sym<until>", " at pos=", rx394_pos)
+    .return (rx394_cur)
+  rx394_restart:
 .annotate 'line', 4
-    (rx417_rep, rx417_pos, $I10, $P10) = rx417_cur."!mark_fail"(0)
-    lt rx417_pos, -1, rx417_done
-    eq rx417_pos, -1, rx417_fail
+    rx394_cur."!cursor_debug"("NEXT ", "statement_mod_loop:sym<until>")
+  rx394_fail:
+    (rx394_rep, rx394_pos, $I10, $P10) = rx394_cur."!mark_fail"(0)
+    lt rx394_pos, -1, rx394_done
+    eq rx394_pos, -1, rx394_fail
     jump $I10
-  rx417_done:
-    rx417_cur."!cursor_fail"()
-    rx417_cur."!cursor_debug"("FAIL  ", "statement_mod_loop:sym<until>")
-    .return (rx417_cur)
+  rx394_done:
+    rx394_cur."!cursor_fail"()
+    rx394_cur."!cursor_debug"("FAIL  ", "statement_mod_loop:sym<until>")
+    .return (rx394_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_loop:sym<until>"  :subid("96_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_loop:sym<until>"  :subid("96_1279529226.73787") :method
 .annotate 'line', 4
-    $P419 = self."!PREFIX__!subrule"("ws", "until")
-    new $P420, "ResizablePMCArray"
-    push $P420, $P419
-    .return ($P420)
+    $P396 = self."!PREFIX__!subrule"("ws", "until")
+    new $P397, "ResizablePMCArray"
+    push $P397, $P396
+    .return ($P397)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "statement_mod_loop:sym<for>"  :subid("97_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "statement_mod_loop:sym<for>"  :subid("97_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx426_tgt
-    .local int rx426_pos
-    .local int rx426_off
-    .local int rx426_eos
-    .local int rx426_rep
-    .local pmc rx426_cur
-    (rx426_cur, rx426_pos, rx426_tgt) = self."!cursor_start"()
-    rx426_cur."!cursor_debug"("START ", "statement_mod_loop:sym<for>")
-    .lex unicode:"$\x{a2}", rx426_cur
+    .local string rx403_tgt
+    .local int rx403_pos
+    .local int rx403_off
+    .local int rx403_eos
+    .local int rx403_rep
+    .local pmc rx403_cur
+    (rx403_cur, rx403_pos, rx403_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx403_cur
     .local pmc match
     .lex "$/", match
-    length rx426_eos, rx426_tgt
-    gt rx426_pos, rx426_eos, rx426_done
-    set rx426_off, 0
-    lt rx426_pos, 2, rx426_start
-    sub rx426_off, rx426_pos, 1
-    substr rx426_tgt, rx426_tgt, rx426_off
-  rx426_start:
+    length rx403_eos, rx403_tgt
+    gt rx403_pos, rx403_eos, rx403_done
+    set rx403_off, 0
+    lt rx403_pos, 2, rx403_start
+    sub rx403_off, rx403_pos, 1
+    substr rx403_tgt, rx403_tgt, rx403_off
+  rx403_start:
+    eq $I10, 1, rx403_restart
+    rx403_cur."!cursor_debug"("START ", "statement_mod_loop:sym<for>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan430_done
-    goto rxscan430_scan
-  rxscan430_loop:
-    ($P10) = rx426_cur."from"()
+    ne $I10, -1, rxscan407_done
+    goto rxscan407_scan
+  rxscan407_loop:
+    ($P10) = rx403_cur."from"()
     inc $P10
-    set rx426_pos, $P10
-    ge rx426_pos, rx426_eos, rxscan430_done
-  rxscan430_scan:
-    set_addr $I10, rxscan430_loop
-    rx426_cur."!mark_push"(0, rx426_pos, $I10)
-  rxscan430_done:
+    set rx403_pos, $P10
+    ge rx403_pos, rx403_eos, rxscan407_done
+  rxscan407_scan:
+    set_addr $I10, rxscan407_loop
+    rx403_cur."!mark_push"(0, rx403_pos, $I10)
+  rxscan407_done:
 .annotate 'line', 221
   # rx subcapture "sym"
-    set_addr $I10, rxcap_431_fail
-    rx426_cur."!mark_push"(0, rx426_pos, $I10)
+    set_addr $I10, rxcap_408_fail
+    rx403_cur."!mark_push"(0, rx403_pos, $I10)
   # rx literal  "for"
-    add $I11, rx426_pos, 3
-    gt $I11, rx426_eos, rx426_fail
-    sub $I11, rx426_pos, rx426_off
-    substr $S10, rx426_tgt, $I11, 3
-    ne $S10, "for", rx426_fail
-    add rx426_pos, 3
-    set_addr $I10, rxcap_431_fail
-    ($I12, $I11) = rx426_cur."!mark_peek"($I10)
-    rx426_cur."!cursor_pos"($I11)
-    ($P10) = rx426_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx426_pos, "")
-    rx426_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx403_pos, 3
+    gt $I11, rx403_eos, rx403_fail
+    sub $I11, rx403_pos, rx403_off
+    substr $S10, rx403_tgt, $I11, 3
+    ne $S10, "for", rx403_fail
+    add rx403_pos, 3
+    set_addr $I10, rxcap_408_fail
+    ($I12, $I11) = rx403_cur."!mark_peek"($I10)
+    rx403_cur."!cursor_pos"($I11)
+    ($P10) = rx403_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx403_pos, "")
+    rx403_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_431_done
-  rxcap_431_fail:
-    goto rx426_fail
-  rxcap_431_done:
-  # rx subrule "ws" subtype=method negate=
-    rx426_cur."!cursor_pos"(rx426_pos)
-    $P10 = rx426_cur."ws"()
-    unless $P10, rx426_fail
-    rx426_pos = $P10."pos"()
+    goto rxcap_408_done
+  rxcap_408_fail:
+    goto rx403_fail
+  rxcap_408_done:
+  # rx subrule "ws" subtype=method negate=
+    rx403_cur."!cursor_pos"(rx403_pos)
+    $P10 = rx403_cur."ws"()
+    unless $P10, rx403_fail
+    rx403_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx426_cur."!cursor_pos"(rx426_pos)
-    $P10 = rx426_cur."EXPR"()
-    unless $P10, rx426_fail
-    rx426_cur."!mark_push"(0, -1, 0, $P10)
+    rx403_cur."!cursor_pos"(rx403_pos)
+    $P10 = rx403_cur."EXPR"()
+    unless $P10, rx403_fail
+    rx403_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("cond")
-    rx426_pos = $P10."pos"()
+    rx403_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx426_cur."!cursor_pos"(rx426_pos)
-    $P10 = rx426_cur."ws"()
-    unless $P10, rx426_fail
-    rx426_pos = $P10."pos"()
+    rx403_cur."!cursor_pos"(rx403_pos)
+    $P10 = rx403_cur."ws"()
+    unless $P10, rx403_fail
+    rx403_pos = $P10."pos"()
   # rx pass
-    rx426_cur."!cursor_pass"(rx426_pos, "statement_mod_loop:sym<for>")
-    rx426_cur."!cursor_debug"("PASS  ", "statement_mod_loop:sym<for>", " at pos=", rx426_pos)
-    .return (rx426_cur)
-  rx426_fail:
+    rx403_cur."!cursor_pass"(rx403_pos, "statement_mod_loop:sym<for>")
+    rx403_cur."!cursor_debug"("PASS  ", "statement_mod_loop:sym<for>", " at pos=", rx403_pos)
+    .return (rx403_cur)
+  rx403_restart:
 .annotate 'line', 4
-    (rx426_rep, rx426_pos, $I10, $P10) = rx426_cur."!mark_fail"(0)
-    lt rx426_pos, -1, rx426_done
-    eq rx426_pos, -1, rx426_fail
+    rx403_cur."!cursor_debug"("NEXT ", "statement_mod_loop:sym<for>")
+  rx403_fail:
+    (rx403_rep, rx403_pos, $I10, $P10) = rx403_cur."!mark_fail"(0)
+    lt rx403_pos, -1, rx403_done
+    eq rx403_pos, -1, rx403_fail
     jump $I10
-  rx426_done:
-    rx426_cur."!cursor_fail"()
-    rx426_cur."!cursor_debug"("FAIL  ", "statement_mod_loop:sym<for>")
-    .return (rx426_cur)
+  rx403_done:
+    rx403_cur."!cursor_fail"()
+    rx403_cur."!cursor_debug"("FAIL  ", "statement_mod_loop:sym<for>")
+    .return (rx403_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__statement_mod_loop:sym<for>"  :subid("98_1278500537.15927") :method
+.sub "!PREFIX__statement_mod_loop:sym<for>"  :subid("98_1279529226.73787") :method
 .annotate 'line', 4
-    $P428 = self."!PREFIX__!subrule"("ws", "for")
-    new $P429, "ResizablePMCArray"
-    push $P429, $P428
-    .return ($P429)
+    $P405 = self."!PREFIX__!subrule"("ws", "for")
+    new $P406, "ResizablePMCArray"
+    push $P406, $P405
+    .return ($P406)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<fatarrow>"  :subid("99_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<fatarrow>"  :subid("99_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx435_tgt
-    .local int rx435_pos
-    .local int rx435_off
-    .local int rx435_eos
-    .local int rx435_rep
-    .local pmc rx435_cur
-    (rx435_cur, rx435_pos, rx435_tgt) = self."!cursor_start"()
-    rx435_cur."!cursor_debug"("START ", "term:sym<fatarrow>")
-    .lex unicode:"$\x{a2}", rx435_cur
-    .local pmc match
-    .lex "$/", match
-    length rx435_eos, rx435_tgt
-    gt rx435_pos, rx435_eos, rx435_done
-    set rx435_off, 0
-    lt rx435_pos, 2, rx435_start
-    sub rx435_off, rx435_pos, 1
-    substr rx435_tgt, rx435_tgt, rx435_off
-  rx435_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan439_done
-    goto rxscan439_scan
-  rxscan439_loop:
-    ($P10) = rx435_cur."from"()
-    inc $P10
-    set rx435_pos, $P10
-    ge rx435_pos, rx435_eos, rxscan439_done
-  rxscan439_scan:
-    set_addr $I10, rxscan439_loop
-    rx435_cur."!mark_push"(0, rx435_pos, $I10)
-  rxscan439_done:
+    .local string rx412_tgt
+    .local int rx412_pos
+    .local int rx412_off
+    .local int rx412_eos
+    .local int rx412_rep
+    .local pmc rx412_cur
+    (rx412_cur, rx412_pos, rx412_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx412_cur
+    .local pmc match
+    .lex "$/", match
+    length rx412_eos, rx412_tgt
+    gt rx412_pos, rx412_eos, rx412_done
+    set rx412_off, 0
+    lt rx412_pos, 2, rx412_start
+    sub rx412_off, rx412_pos, 1
+    substr rx412_tgt, rx412_tgt, rx412_off
+  rx412_start:
+    eq $I10, 1, rx412_restart
+    rx412_cur."!cursor_debug"("START ", "term:sym<fatarrow>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan416_done
+    goto rxscan416_scan
+  rxscan416_loop:
+    ($P10) = rx412_cur."from"()
+    inc $P10
+    set rx412_pos, $P10
+    ge rx412_pos, rx412_eos, rxscan416_done
+  rxscan416_scan:
+    set_addr $I10, rxscan416_loop
+    rx412_cur."!mark_push"(0, rx412_pos, $I10)
+  rxscan416_done:
 .annotate 'line', 225
   # rx subrule "fatarrow" subtype=capture negate=
-    rx435_cur."!cursor_pos"(rx435_pos)
-    $P10 = rx435_cur."fatarrow"()
-    unless $P10, rx435_fail
-    rx435_cur."!mark_push"(0, -1, 0, $P10)
+    rx412_cur."!cursor_pos"(rx412_pos)
+    $P10 = rx412_cur."fatarrow"()
+    unless $P10, rx412_fail
+    rx412_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("fatarrow")
-    rx435_pos = $P10."pos"()
+    rx412_pos = $P10."pos"()
   # rx pass
-    rx435_cur."!cursor_pass"(rx435_pos, "term:sym<fatarrow>")
-    rx435_cur."!cursor_debug"("PASS  ", "term:sym<fatarrow>", " at pos=", rx435_pos)
-    .return (rx435_cur)
-  rx435_fail:
+    rx412_cur."!cursor_pass"(rx412_pos, "term:sym<fatarrow>")
+    rx412_cur."!cursor_debug"("PASS  ", "term:sym<fatarrow>", " at pos=", rx412_pos)
+    .return (rx412_cur)
+  rx412_restart:
 .annotate 'line', 4
-    (rx435_rep, rx435_pos, $I10, $P10) = rx435_cur."!mark_fail"(0)
-    lt rx435_pos, -1, rx435_done
-    eq rx435_pos, -1, rx435_fail
+    rx412_cur."!cursor_debug"("NEXT ", "term:sym<fatarrow>")
+  rx412_fail:
+    (rx412_rep, rx412_pos, $I10, $P10) = rx412_cur."!mark_fail"(0)
+    lt rx412_pos, -1, rx412_done
+    eq rx412_pos, -1, rx412_fail
     jump $I10
-  rx435_done:
-    rx435_cur."!cursor_fail"()
-    rx435_cur."!cursor_debug"("FAIL  ", "term:sym<fatarrow>")
-    .return (rx435_cur)
+  rx412_done:
+    rx412_cur."!cursor_fail"()
+    rx412_cur."!cursor_debug"("FAIL  ", "term:sym<fatarrow>")
+    .return (rx412_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<fatarrow>"  :subid("100_1278500537.15927") :method
+.sub "!PREFIX__term:sym<fatarrow>"  :subid("100_1279529226.73787") :method
 .annotate 'line', 4
-    $P437 = self."!PREFIX__!subrule"("fatarrow", "")
-    new $P438, "ResizablePMCArray"
-    push $P438, $P437
-    .return ($P438)
+    $P414 = self."!PREFIX__!subrule"("fatarrow", "")
+    new $P415, "ResizablePMCArray"
+    push $P415, $P414
+    .return ($P415)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<colonpair>"  :subid("101_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<colonpair>"  :subid("101_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx441_tgt
-    .local int rx441_pos
-    .local int rx441_off
-    .local int rx441_eos
-    .local int rx441_rep
-    .local pmc rx441_cur
-    (rx441_cur, rx441_pos, rx441_tgt) = self."!cursor_start"()
-    rx441_cur."!cursor_debug"("START ", "term:sym<colonpair>")
-    .lex unicode:"$\x{a2}", rx441_cur
-    .local pmc match
-    .lex "$/", match
-    length rx441_eos, rx441_tgt
-    gt rx441_pos, rx441_eos, rx441_done
-    set rx441_off, 0
-    lt rx441_pos, 2, rx441_start
-    sub rx441_off, rx441_pos, 1
-    substr rx441_tgt, rx441_tgt, rx441_off
-  rx441_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan445_done
-    goto rxscan445_scan
-  rxscan445_loop:
-    ($P10) = rx441_cur."from"()
-    inc $P10
-    set rx441_pos, $P10
-    ge rx441_pos, rx441_eos, rxscan445_done
-  rxscan445_scan:
-    set_addr $I10, rxscan445_loop
-    rx441_cur."!mark_push"(0, rx441_pos, $I10)
-  rxscan445_done:
+    .local string rx418_tgt
+    .local int rx418_pos
+    .local int rx418_off
+    .local int rx418_eos
+    .local int rx418_rep
+    .local pmc rx418_cur
+    (rx418_cur, rx418_pos, rx418_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx418_cur
+    .local pmc match
+    .lex "$/", match
+    length rx418_eos, rx418_tgt
+    gt rx418_pos, rx418_eos, rx418_done
+    set rx418_off, 0
+    lt rx418_pos, 2, rx418_start
+    sub rx418_off, rx418_pos, 1
+    substr rx418_tgt, rx418_tgt, rx418_off
+  rx418_start:
+    eq $I10, 1, rx418_restart
+    rx418_cur."!cursor_debug"("START ", "term:sym<colonpair>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan422_done
+    goto rxscan422_scan
+  rxscan422_loop:
+    ($P10) = rx418_cur."from"()
+    inc $P10
+    set rx418_pos, $P10
+    ge rx418_pos, rx418_eos, rxscan422_done
+  rxscan422_scan:
+    set_addr $I10, rxscan422_loop
+    rx418_cur."!mark_push"(0, rx418_pos, $I10)
+  rxscan422_done:
 .annotate 'line', 226
   # rx subrule "colonpair" subtype=capture negate=
-    rx441_cur."!cursor_pos"(rx441_pos)
-    $P10 = rx441_cur."colonpair"()
-    unless $P10, rx441_fail
-    rx441_cur."!mark_push"(0, -1, 0, $P10)
+    rx418_cur."!cursor_pos"(rx418_pos)
+    $P10 = rx418_cur."colonpair"()
+    unless $P10, rx418_fail
+    rx418_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("colonpair")
-    rx441_pos = $P10."pos"()
+    rx418_pos = $P10."pos"()
   # rx pass
-    rx441_cur."!cursor_pass"(rx441_pos, "term:sym<colonpair>")
-    rx441_cur."!cursor_debug"("PASS  ", "term:sym<colonpair>", " at pos=", rx441_pos)
-    .return (rx441_cur)
-  rx441_fail:
+    rx418_cur."!cursor_pass"(rx418_pos, "term:sym<colonpair>")
+    rx418_cur."!cursor_debug"("PASS  ", "term:sym<colonpair>", " at pos=", rx418_pos)
+    .return (rx418_cur)
+  rx418_restart:
 .annotate 'line', 4
-    (rx441_rep, rx441_pos, $I10, $P10) = rx441_cur."!mark_fail"(0)
-    lt rx441_pos, -1, rx441_done
-    eq rx441_pos, -1, rx441_fail
+    rx418_cur."!cursor_debug"("NEXT ", "term:sym<colonpair>")
+  rx418_fail:
+    (rx418_rep, rx418_pos, $I10, $P10) = rx418_cur."!mark_fail"(0)
+    lt rx418_pos, -1, rx418_done
+    eq rx418_pos, -1, rx418_fail
     jump $I10
-  rx441_done:
-    rx441_cur."!cursor_fail"()
-    rx441_cur."!cursor_debug"("FAIL  ", "term:sym<colonpair>")
-    .return (rx441_cur)
+  rx418_done:
+    rx418_cur."!cursor_fail"()
+    rx418_cur."!cursor_debug"("FAIL  ", "term:sym<colonpair>")
+    .return (rx418_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<colonpair>"  :subid("102_1278500537.15927") :method
+.sub "!PREFIX__term:sym<colonpair>"  :subid("102_1279529226.73787") :method
 .annotate 'line', 4
-    $P443 = self."!PREFIX__!subrule"("colonpair", "")
-    new $P444, "ResizablePMCArray"
-    push $P444, $P443
-    .return ($P444)
+    $P420 = self."!PREFIX__!subrule"("colonpair", "")
+    new $P421, "ResizablePMCArray"
+    push $P421, $P420
+    .return ($P421)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<variable>"  :subid("103_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<variable>"  :subid("103_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx447_tgt
-    .local int rx447_pos
-    .local int rx447_off
-    .local int rx447_eos
-    .local int rx447_rep
-    .local pmc rx447_cur
-    (rx447_cur, rx447_pos, rx447_tgt) = self."!cursor_start"()
-    rx447_cur."!cursor_debug"("START ", "term:sym<variable>")
-    .lex unicode:"$\x{a2}", rx447_cur
+    .local string rx424_tgt
+    .local int rx424_pos
+    .local int rx424_off
+    .local int rx424_eos
+    .local int rx424_rep
+    .local pmc rx424_cur
+    (rx424_cur, rx424_pos, rx424_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx424_cur
     .local pmc match
     .lex "$/", match
-    length rx447_eos, rx447_tgt
-    gt rx447_pos, rx447_eos, rx447_done
-    set rx447_off, 0
-    lt rx447_pos, 2, rx447_start
-    sub rx447_off, rx447_pos, 1
-    substr rx447_tgt, rx447_tgt, rx447_off
-  rx447_start:
+    length rx424_eos, rx424_tgt
+    gt rx424_pos, rx424_eos, rx424_done
+    set rx424_off, 0
+    lt rx424_pos, 2, rx424_start
+    sub rx424_off, rx424_pos, 1
+    substr rx424_tgt, rx424_tgt, rx424_off
+  rx424_start:
+    eq $I10, 1, rx424_restart
+    rx424_cur."!cursor_debug"("START ", "term:sym<variable>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan451_done
-    goto rxscan451_scan
-  rxscan451_loop:
-    ($P10) = rx447_cur."from"()
+    ne $I10, -1, rxscan428_done
+    goto rxscan428_scan
+  rxscan428_loop:
+    ($P10) = rx424_cur."from"()
     inc $P10
-    set rx447_pos, $P10
-    ge rx447_pos, rx447_eos, rxscan451_done
-  rxscan451_scan:
-    set_addr $I10, rxscan451_loop
-    rx447_cur."!mark_push"(0, rx447_pos, $I10)
-  rxscan451_done:
+    set rx424_pos, $P10
+    ge rx424_pos, rx424_eos, rxscan428_done
+  rxscan428_scan:
+    set_addr $I10, rxscan428_loop
+    rx424_cur."!mark_push"(0, rx424_pos, $I10)
+  rxscan428_done:
 .annotate 'line', 227
   # rx subrule "variable" subtype=capture negate=
-    rx447_cur."!cursor_pos"(rx447_pos)
-    $P10 = rx447_cur."variable"()
-    unless $P10, rx447_fail
-    rx447_cur."!mark_push"(0, -1, 0, $P10)
+    rx424_cur."!cursor_pos"(rx424_pos)
+    $P10 = rx424_cur."variable"()
+    unless $P10, rx424_fail
+    rx424_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("variable")
-    rx447_pos = $P10."pos"()
+    rx424_pos = $P10."pos"()
   # rx pass
-    rx447_cur."!cursor_pass"(rx447_pos, "term:sym<variable>")
-    rx447_cur."!cursor_debug"("PASS  ", "term:sym<variable>", " at pos=", rx447_pos)
-    .return (rx447_cur)
-  rx447_fail:
+    rx424_cur."!cursor_pass"(rx424_pos, "term:sym<variable>")
+    rx424_cur."!cursor_debug"("PASS  ", "term:sym<variable>", " at pos=", rx424_pos)
+    .return (rx424_cur)
+  rx424_restart:
 .annotate 'line', 4
-    (rx447_rep, rx447_pos, $I10, $P10) = rx447_cur."!mark_fail"(0)
-    lt rx447_pos, -1, rx447_done
-    eq rx447_pos, -1, rx447_fail
+    rx424_cur."!cursor_debug"("NEXT ", "term:sym<variable>")
+  rx424_fail:
+    (rx424_rep, rx424_pos, $I10, $P10) = rx424_cur."!mark_fail"(0)
+    lt rx424_pos, -1, rx424_done
+    eq rx424_pos, -1, rx424_fail
     jump $I10
-  rx447_done:
-    rx447_cur."!cursor_fail"()
-    rx447_cur."!cursor_debug"("FAIL  ", "term:sym<variable>")
-    .return (rx447_cur)
+  rx424_done:
+    rx424_cur."!cursor_fail"()
+    rx424_cur."!cursor_debug"("FAIL  ", "term:sym<variable>")
+    .return (rx424_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<variable>"  :subid("104_1278500537.15927") :method
+.sub "!PREFIX__term:sym<variable>"  :subid("104_1279529226.73787") :method
 .annotate 'line', 4
-    $P449 = self."!PREFIX__!subrule"("variable", "")
-    new $P450, "ResizablePMCArray"
-    push $P450, $P449
-    .return ($P450)
+    $P426 = self."!PREFIX__!subrule"("variable", "")
+    new $P427, "ResizablePMCArray"
+    push $P427, $P426
+    .return ($P427)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<package_declarator>"  :subid("105_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<package_declarator>"  :subid("105_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx453_tgt
-    .local int rx453_pos
-    .local int rx453_off
-    .local int rx453_eos
-    .local int rx453_rep
-    .local pmc rx453_cur
-    (rx453_cur, rx453_pos, rx453_tgt) = self."!cursor_start"()
-    rx453_cur."!cursor_debug"("START ", "term:sym<package_declarator>")
-    .lex unicode:"$\x{a2}", rx453_cur
-    .local pmc match
-    .lex "$/", match
-    length rx453_eos, rx453_tgt
-    gt rx453_pos, rx453_eos, rx453_done
-    set rx453_off, 0
-    lt rx453_pos, 2, rx453_start
-    sub rx453_off, rx453_pos, 1
-    substr rx453_tgt, rx453_tgt, rx453_off
-  rx453_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan457_done
-    goto rxscan457_scan
-  rxscan457_loop:
-    ($P10) = rx453_cur."from"()
-    inc $P10
-    set rx453_pos, $P10
-    ge rx453_pos, rx453_eos, rxscan457_done
-  rxscan457_scan:
-    set_addr $I10, rxscan457_loop
-    rx453_cur."!mark_push"(0, rx453_pos, $I10)
-  rxscan457_done:
+    .local string rx430_tgt
+    .local int rx430_pos
+    .local int rx430_off
+    .local int rx430_eos
+    .local int rx430_rep
+    .local pmc rx430_cur
+    (rx430_cur, rx430_pos, rx430_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx430_cur
+    .local pmc match
+    .lex "$/", match
+    length rx430_eos, rx430_tgt
+    gt rx430_pos, rx430_eos, rx430_done
+    set rx430_off, 0
+    lt rx430_pos, 2, rx430_start
+    sub rx430_off, rx430_pos, 1
+    substr rx430_tgt, rx430_tgt, rx430_off
+  rx430_start:
+    eq $I10, 1, rx430_restart
+    rx430_cur."!cursor_debug"("START ", "term:sym<package_declarator>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan434_done
+    goto rxscan434_scan
+  rxscan434_loop:
+    ($P10) = rx430_cur."from"()
+    inc $P10
+    set rx430_pos, $P10
+    ge rx430_pos, rx430_eos, rxscan434_done
+  rxscan434_scan:
+    set_addr $I10, rxscan434_loop
+    rx430_cur."!mark_push"(0, rx430_pos, $I10)
+  rxscan434_done:
 .annotate 'line', 228
   # rx subrule "package_declarator" subtype=capture negate=
-    rx453_cur."!cursor_pos"(rx453_pos)
-    $P10 = rx453_cur."package_declarator"()
-    unless $P10, rx453_fail
-    rx453_cur."!mark_push"(0, -1, 0, $P10)
+    rx430_cur."!cursor_pos"(rx430_pos)
+    $P10 = rx430_cur."package_declarator"()
+    unless $P10, rx430_fail
+    rx430_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("package_declarator")
-    rx453_pos = $P10."pos"()
+    rx430_pos = $P10."pos"()
   # rx pass
-    rx453_cur."!cursor_pass"(rx453_pos, "term:sym<package_declarator>")
-    rx453_cur."!cursor_debug"("PASS  ", "term:sym<package_declarator>", " at pos=", rx453_pos)
-    .return (rx453_cur)
-  rx453_fail:
+    rx430_cur."!cursor_pass"(rx430_pos, "term:sym<package_declarator>")
+    rx430_cur."!cursor_debug"("PASS  ", "term:sym<package_declarator>", " at pos=", rx430_pos)
+    .return (rx430_cur)
+  rx430_restart:
 .annotate 'line', 4
-    (rx453_rep, rx453_pos, $I10, $P10) = rx453_cur."!mark_fail"(0)
-    lt rx453_pos, -1, rx453_done
-    eq rx453_pos, -1, rx453_fail
+    rx430_cur."!cursor_debug"("NEXT ", "term:sym<package_declarator>")
+  rx430_fail:
+    (rx430_rep, rx430_pos, $I10, $P10) = rx430_cur."!mark_fail"(0)
+    lt rx430_pos, -1, rx430_done
+    eq rx430_pos, -1, rx430_fail
     jump $I10
-  rx453_done:
-    rx453_cur."!cursor_fail"()
-    rx453_cur."!cursor_debug"("FAIL  ", "term:sym<package_declarator>")
-    .return (rx453_cur)
+  rx430_done:
+    rx430_cur."!cursor_fail"()
+    rx430_cur."!cursor_debug"("FAIL  ", "term:sym<package_declarator>")
+    .return (rx430_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<package_declarator>"  :subid("106_1278500537.15927") :method
+.sub "!PREFIX__term:sym<package_declarator>"  :subid("106_1279529226.73787") :method
 .annotate 'line', 4
-    $P455 = self."!PREFIX__!subrule"("package_declarator", "")
-    new $P456, "ResizablePMCArray"
-    push $P456, $P455
-    .return ($P456)
+    $P432 = self."!PREFIX__!subrule"("package_declarator", "")
+    new $P433, "ResizablePMCArray"
+    push $P433, $P432
+    .return ($P433)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<scope_declarator>"  :subid("107_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<scope_declarator>"  :subid("107_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx459_tgt
-    .local int rx459_pos
-    .local int rx459_off
-    .local int rx459_eos
-    .local int rx459_rep
-    .local pmc rx459_cur
-    (rx459_cur, rx459_pos, rx459_tgt) = self."!cursor_start"()
-    rx459_cur."!cursor_debug"("START ", "term:sym<scope_declarator>")
-    .lex unicode:"$\x{a2}", rx459_cur
+    .local string rx436_tgt
+    .local int rx436_pos
+    .local int rx436_off
+    .local int rx436_eos
+    .local int rx436_rep
+    .local pmc rx436_cur
+    (rx436_cur, rx436_pos, rx436_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx436_cur
     .local pmc match
     .lex "$/", match
-    length rx459_eos, rx459_tgt
-    gt rx459_pos, rx459_eos, rx459_done
-    set rx459_off, 0
-    lt rx459_pos, 2, rx459_start
-    sub rx459_off, rx459_pos, 1
-    substr rx459_tgt, rx459_tgt, rx459_off
-  rx459_start:
+    length rx436_eos, rx436_tgt
+    gt rx436_pos, rx436_eos, rx436_done
+    set rx436_off, 0
+    lt rx436_pos, 2, rx436_start
+    sub rx436_off, rx436_pos, 1
+    substr rx436_tgt, rx436_tgt, rx436_off
+  rx436_start:
+    eq $I10, 1, rx436_restart
+    rx436_cur."!cursor_debug"("START ", "term:sym<scope_declarator>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan463_done
-    goto rxscan463_scan
-  rxscan463_loop:
-    ($P10) = rx459_cur."from"()
+    ne $I10, -1, rxscan440_done
+    goto rxscan440_scan
+  rxscan440_loop:
+    ($P10) = rx436_cur."from"()
     inc $P10
-    set rx459_pos, $P10
-    ge rx459_pos, rx459_eos, rxscan463_done
-  rxscan463_scan:
-    set_addr $I10, rxscan463_loop
-    rx459_cur."!mark_push"(0, rx459_pos, $I10)
-  rxscan463_done:
+    set rx436_pos, $P10
+    ge rx436_pos, rx436_eos, rxscan440_done
+  rxscan440_scan:
+    set_addr $I10, rxscan440_loop
+    rx436_cur."!mark_push"(0, rx436_pos, $I10)
+  rxscan440_done:
 .annotate 'line', 229
   # rx subrule "scope_declarator" subtype=capture negate=
-    rx459_cur."!cursor_pos"(rx459_pos)
-    $P10 = rx459_cur."scope_declarator"()
-    unless $P10, rx459_fail
-    rx459_cur."!mark_push"(0, -1, 0, $P10)
+    rx436_cur."!cursor_pos"(rx436_pos)
+    $P10 = rx436_cur."scope_declarator"()
+    unless $P10, rx436_fail
+    rx436_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("scope_declarator")
-    rx459_pos = $P10."pos"()
+    rx436_pos = $P10."pos"()
   # rx pass
-    rx459_cur."!cursor_pass"(rx459_pos, "term:sym<scope_declarator>")
-    rx459_cur."!cursor_debug"("PASS  ", "term:sym<scope_declarator>", " at pos=", rx459_pos)
-    .return (rx459_cur)
-  rx459_fail:
+    rx436_cur."!cursor_pass"(rx436_pos, "term:sym<scope_declarator>")
+    rx436_cur."!cursor_debug"("PASS  ", "term:sym<scope_declarator>", " at pos=", rx436_pos)
+    .return (rx436_cur)
+  rx436_restart:
 .annotate 'line', 4
-    (rx459_rep, rx459_pos, $I10, $P10) = rx459_cur."!mark_fail"(0)
-    lt rx459_pos, -1, rx459_done
-    eq rx459_pos, -1, rx459_fail
+    rx436_cur."!cursor_debug"("NEXT ", "term:sym<scope_declarator>")
+  rx436_fail:
+    (rx436_rep, rx436_pos, $I10, $P10) = rx436_cur."!mark_fail"(0)
+    lt rx436_pos, -1, rx436_done
+    eq rx436_pos, -1, rx436_fail
     jump $I10
-  rx459_done:
-    rx459_cur."!cursor_fail"()
-    rx459_cur."!cursor_debug"("FAIL  ", "term:sym<scope_declarator>")
-    .return (rx459_cur)
+  rx436_done:
+    rx436_cur."!cursor_fail"()
+    rx436_cur."!cursor_debug"("FAIL  ", "term:sym<scope_declarator>")
+    .return (rx436_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<scope_declarator>"  :subid("108_1278500537.15927") :method
+.sub "!PREFIX__term:sym<scope_declarator>"  :subid("108_1279529226.73787") :method
 .annotate 'line', 4
-    $P461 = self."!PREFIX__!subrule"("scope_declarator", "")
-    new $P462, "ResizablePMCArray"
-    push $P462, $P461
-    .return ($P462)
+    $P438 = self."!PREFIX__!subrule"("scope_declarator", "")
+    new $P439, "ResizablePMCArray"
+    push $P439, $P438
+    .return ($P439)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<routine_declarator>"  :subid("109_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<routine_declarator>"  :subid("109_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx465_tgt
-    .local int rx465_pos
-    .local int rx465_off
-    .local int rx465_eos
-    .local int rx465_rep
-    .local pmc rx465_cur
-    (rx465_cur, rx465_pos, rx465_tgt) = self."!cursor_start"()
-    rx465_cur."!cursor_debug"("START ", "term:sym<routine_declarator>")
-    .lex unicode:"$\x{a2}", rx465_cur
-    .local pmc match
-    .lex "$/", match
-    length rx465_eos, rx465_tgt
-    gt rx465_pos, rx465_eos, rx465_done
-    set rx465_off, 0
-    lt rx465_pos, 2, rx465_start
-    sub rx465_off, rx465_pos, 1
-    substr rx465_tgt, rx465_tgt, rx465_off
-  rx465_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan469_done
-    goto rxscan469_scan
-  rxscan469_loop:
-    ($P10) = rx465_cur."from"()
-    inc $P10
-    set rx465_pos, $P10
-    ge rx465_pos, rx465_eos, rxscan469_done
-  rxscan469_scan:
-    set_addr $I10, rxscan469_loop
-    rx465_cur."!mark_push"(0, rx465_pos, $I10)
-  rxscan469_done:
+    .local string rx442_tgt
+    .local int rx442_pos
+    .local int rx442_off
+    .local int rx442_eos
+    .local int rx442_rep
+    .local pmc rx442_cur
+    (rx442_cur, rx442_pos, rx442_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx442_cur
+    .local pmc match
+    .lex "$/", match
+    length rx442_eos, rx442_tgt
+    gt rx442_pos, rx442_eos, rx442_done
+    set rx442_off, 0
+    lt rx442_pos, 2, rx442_start
+    sub rx442_off, rx442_pos, 1
+    substr rx442_tgt, rx442_tgt, rx442_off
+  rx442_start:
+    eq $I10, 1, rx442_restart
+    rx442_cur."!cursor_debug"("START ", "term:sym<routine_declarator>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan446_done
+    goto rxscan446_scan
+  rxscan446_loop:
+    ($P10) = rx442_cur."from"()
+    inc $P10
+    set rx442_pos, $P10
+    ge rx442_pos, rx442_eos, rxscan446_done
+  rxscan446_scan:
+    set_addr $I10, rxscan446_loop
+    rx442_cur."!mark_push"(0, rx442_pos, $I10)
+  rxscan446_done:
 .annotate 'line', 230
   # rx subrule "routine_declarator" subtype=capture negate=
-    rx465_cur."!cursor_pos"(rx465_pos)
-    $P10 = rx465_cur."routine_declarator"()
-    unless $P10, rx465_fail
-    rx465_cur."!mark_push"(0, -1, 0, $P10)
+    rx442_cur."!cursor_pos"(rx442_pos)
+    $P10 = rx442_cur."routine_declarator"()
+    unless $P10, rx442_fail
+    rx442_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("routine_declarator")
-    rx465_pos = $P10."pos"()
+    rx442_pos = $P10."pos"()
   # rx pass
-    rx465_cur."!cursor_pass"(rx465_pos, "term:sym<routine_declarator>")
-    rx465_cur."!cursor_debug"("PASS  ", "term:sym<routine_declarator>", " at pos=", rx465_pos)
-    .return (rx465_cur)
-  rx465_fail:
+    rx442_cur."!cursor_pass"(rx442_pos, "term:sym<routine_declarator>")
+    rx442_cur."!cursor_debug"("PASS  ", "term:sym<routine_declarator>", " at pos=", rx442_pos)
+    .return (rx442_cur)
+  rx442_restart:
 .annotate 'line', 4
-    (rx465_rep, rx465_pos, $I10, $P10) = rx465_cur."!mark_fail"(0)
-    lt rx465_pos, -1, rx465_done
-    eq rx465_pos, -1, rx465_fail
+    rx442_cur."!cursor_debug"("NEXT ", "term:sym<routine_declarator>")
+  rx442_fail:
+    (rx442_rep, rx442_pos, $I10, $P10) = rx442_cur."!mark_fail"(0)
+    lt rx442_pos, -1, rx442_done
+    eq rx442_pos, -1, rx442_fail
     jump $I10
-  rx465_done:
-    rx465_cur."!cursor_fail"()
-    rx465_cur."!cursor_debug"("FAIL  ", "term:sym<routine_declarator>")
-    .return (rx465_cur)
+  rx442_done:
+    rx442_cur."!cursor_fail"()
+    rx442_cur."!cursor_debug"("FAIL  ", "term:sym<routine_declarator>")
+    .return (rx442_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<routine_declarator>"  :subid("110_1278500537.15927") :method
+.sub "!PREFIX__term:sym<routine_declarator>"  :subid("110_1279529226.73787") :method
 .annotate 'line', 4
-    $P467 = self."!PREFIX__!subrule"("routine_declarator", "")
-    new $P468, "ResizablePMCArray"
-    push $P468, $P467
-    .return ($P468)
+    $P444 = self."!PREFIX__!subrule"("routine_declarator", "")
+    new $P445, "ResizablePMCArray"
+    push $P445, $P444
+    .return ($P445)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<multi_declarator>"  :subid("111_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<multi_declarator>"  :subid("111_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .const 'Sub' $P476 = "113_1278500537.15927" 
-    capture_lex $P476
-    .local string rx471_tgt
-    .local int rx471_pos
-    .local int rx471_off
-    .local int rx471_eos
-    .local int rx471_rep
-    .local pmc rx471_cur
-    (rx471_cur, rx471_pos, rx471_tgt) = self."!cursor_start"()
-    rx471_cur."!cursor_debug"("START ", "term:sym<multi_declarator>")
-    .lex unicode:"$\x{a2}", rx471_cur
+    .const 'Sub' $P453 = "113_1279529226.73787" 
+    capture_lex $P453
+    .local string rx448_tgt
+    .local int rx448_pos
+    .local int rx448_off
+    .local int rx448_eos
+    .local int rx448_rep
+    .local pmc rx448_cur
+    (rx448_cur, rx448_pos, rx448_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx448_cur
     .local pmc match
     .lex "$/", match
-    length rx471_eos, rx471_tgt
-    gt rx471_pos, rx471_eos, rx471_done
-    set rx471_off, 0
-    lt rx471_pos, 2, rx471_start
-    sub rx471_off, rx471_pos, 1
-    substr rx471_tgt, rx471_tgt, rx471_off
-  rx471_start:
+    length rx448_eos, rx448_tgt
+    gt rx448_pos, rx448_eos, rx448_done
+    set rx448_off, 0
+    lt rx448_pos, 2, rx448_start
+    sub rx448_off, rx448_pos, 1
+    substr rx448_tgt, rx448_tgt, rx448_off
+  rx448_start:
+    eq $I10, 1, rx448_restart
+    rx448_cur."!cursor_debug"("START ", "term:sym<multi_declarator>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan474_done
-    goto rxscan474_scan
-  rxscan474_loop:
-    ($P10) = rx471_cur."from"()
+    ne $I10, -1, rxscan451_done
+    goto rxscan451_scan
+  rxscan451_loop:
+    ($P10) = rx448_cur."from"()
     inc $P10
-    set rx471_pos, $P10
-    ge rx471_pos, rx471_eos, rxscan474_done
-  rxscan474_scan:
-    set_addr $I10, rxscan474_loop
-    rx471_cur."!mark_push"(0, rx471_pos, $I10)
-  rxscan474_done:
+    set rx448_pos, $P10
+    ge rx448_pos, rx448_eos, rxscan451_done
+  rxscan451_scan:
+    set_addr $I10, rxscan451_loop
+    rx448_cur."!mark_push"(0, rx448_pos, $I10)
+  rxscan451_done:
 .annotate 'line', 231
   # rx subrule "before" subtype=zerowidth negate=
-    rx471_cur."!cursor_pos"(rx471_pos)
-    .const 'Sub' $P476 = "113_1278500537.15927" 
-    capture_lex $P476
-    $P10 = rx471_cur."before"($P476)
-    unless $P10, rx471_fail
+    rx448_cur."!cursor_pos"(rx448_pos)
+    .const 'Sub' $P453 = "113_1279529226.73787" 
+    capture_lex $P453
+    $P10 = rx448_cur."before"($P453)
+    unless $P10, rx448_fail
   # rx subrule "multi_declarator" subtype=capture negate=
-    rx471_cur."!cursor_pos"(rx471_pos)
-    $P10 = rx471_cur."multi_declarator"()
-    unless $P10, rx471_fail
-    rx471_cur."!mark_push"(0, -1, 0, $P10)
+    rx448_cur."!cursor_pos"(rx448_pos)
+    $P10 = rx448_cur."multi_declarator"()
+    unless $P10, rx448_fail
+    rx448_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("multi_declarator")
-    rx471_pos = $P10."pos"()
+    rx448_pos = $P10."pos"()
   # rx pass
-    rx471_cur."!cursor_pass"(rx471_pos, "term:sym<multi_declarator>")
-    rx471_cur."!cursor_debug"("PASS  ", "term:sym<multi_declarator>", " at pos=", rx471_pos)
-    .return (rx471_cur)
-  rx471_fail:
+    rx448_cur."!cursor_pass"(rx448_pos, "term:sym<multi_declarator>")
+    rx448_cur."!cursor_debug"("PASS  ", "term:sym<multi_declarator>", " at pos=", rx448_pos)
+    .return (rx448_cur)
+  rx448_restart:
 .annotate 'line', 4
-    (rx471_rep, rx471_pos, $I10, $P10) = rx471_cur."!mark_fail"(0)
-    lt rx471_pos, -1, rx471_done
-    eq rx471_pos, -1, rx471_fail
+    rx448_cur."!cursor_debug"("NEXT ", "term:sym<multi_declarator>")
+  rx448_fail:
+    (rx448_rep, rx448_pos, $I10, $P10) = rx448_cur."!mark_fail"(0)
+    lt rx448_pos, -1, rx448_done
+    eq rx448_pos, -1, rx448_fail
     jump $I10
-  rx471_done:
-    rx471_cur."!cursor_fail"()
-    rx471_cur."!cursor_debug"("FAIL  ", "term:sym<multi_declarator>")
-    .return (rx471_cur)
+  rx448_done:
+    rx448_cur."!cursor_fail"()
+    rx448_cur."!cursor_debug"("FAIL  ", "term:sym<multi_declarator>")
+    .return (rx448_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<multi_declarator>"  :subid("112_1278500537.15927") :method
+.sub "!PREFIX__term:sym<multi_declarator>"  :subid("112_1279529226.73787") :method
 .annotate 'line', 4
-    new $P473, "ResizablePMCArray"
-    push $P473, ""
-    .return ($P473)
+    new $P450, "ResizablePMCArray"
+    push $P450, ""
+    .return ($P450)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block475"  :anon :subid("113_1278500537.15927") :method :outer("111_1278500537.15927")
+.sub "_block452"  :anon :subid("113_1279529226.73787") :method :outer("111_1279529226.73787")
 .annotate 'line', 231
-    .local string rx477_tgt
-    .local int rx477_pos
-    .local int rx477_off
-    .local int rx477_eos
-    .local int rx477_rep
-    .local pmc rx477_cur
-    (rx477_cur, rx477_pos, rx477_tgt) = self."!cursor_start"()
-    rx477_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx477_cur
-    .local pmc match
-    .lex "$/", match
-    length rx477_eos, rx477_tgt
-    gt rx477_pos, rx477_eos, rx477_done
-    set rx477_off, 0
-    lt rx477_pos, 2, rx477_start
-    sub rx477_off, rx477_pos, 1
-    substr rx477_tgt, rx477_tgt, rx477_off
-  rx477_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan478_done
-    goto rxscan478_scan
-  rxscan478_loop:
-    ($P10) = rx477_cur."from"()
-    inc $P10
-    set rx477_pos, $P10
-    ge rx477_pos, rx477_eos, rxscan478_done
-  rxscan478_scan:
-    set_addr $I10, rxscan478_loop
-    rx477_cur."!mark_push"(0, rx477_pos, $I10)
-  rxscan478_done:
-  alt479_0:
-    set_addr $I10, alt479_1
-    rx477_cur."!mark_push"(0, rx477_pos, $I10)
+    .local string rx454_tgt
+    .local int rx454_pos
+    .local int rx454_off
+    .local int rx454_eos
+    .local int rx454_rep
+    .local pmc rx454_cur
+    (rx454_cur, rx454_pos, rx454_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx454_cur
+    .local pmc match
+    .lex "$/", match
+    length rx454_eos, rx454_tgt
+    gt rx454_pos, rx454_eos, rx454_done
+    set rx454_off, 0
+    lt rx454_pos, 2, rx454_start
+    sub rx454_off, rx454_pos, 1
+    substr rx454_tgt, rx454_tgt, rx454_off
+  rx454_start:
+    eq $I10, 1, rx454_restart
+    rx454_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan455_done
+    goto rxscan455_scan
+  rxscan455_loop:
+    ($P10) = rx454_cur."from"()
+    inc $P10
+    set rx454_pos, $P10
+    ge rx454_pos, rx454_eos, rxscan455_done
+  rxscan455_scan:
+    set_addr $I10, rxscan455_loop
+    rx454_cur."!mark_push"(0, rx454_pos, $I10)
+  rxscan455_done:
+  alt456_0:
+    set_addr $I10, alt456_1
+    rx454_cur."!mark_push"(0, rx454_pos, $I10)
   # rx literal  "multi"
-    add $I11, rx477_pos, 5
-    gt $I11, rx477_eos, rx477_fail
-    sub $I11, rx477_pos, rx477_off
-    substr $S10, rx477_tgt, $I11, 5
-    ne $S10, "multi", rx477_fail
-    add rx477_pos, 5
-    goto alt479_end
-  alt479_1:
-    set_addr $I10, alt479_2
-    rx477_cur."!mark_push"(0, rx477_pos, $I10)
+    add $I11, rx454_pos, 5
+    gt $I11, rx454_eos, rx454_fail
+    sub $I11, rx454_pos, rx454_off
+    substr $S10, rx454_tgt, $I11, 5
+    ne $S10, "multi", rx454_fail
+    add rx454_pos, 5
+    goto alt456_end
+  alt456_1:
+    set_addr $I10, alt456_2
+    rx454_cur."!mark_push"(0, rx454_pos, $I10)
   # rx literal  "proto"
-    add $I11, rx477_pos, 5
-    gt $I11, rx477_eos, rx477_fail
-    sub $I11, rx477_pos, rx477_off
-    substr $S10, rx477_tgt, $I11, 5
-    ne $S10, "proto", rx477_fail
-    add rx477_pos, 5
-    goto alt479_end
-  alt479_2:
+    add $I11, rx454_pos, 5
+    gt $I11, rx454_eos, rx454_fail
+    sub $I11, rx454_pos, rx454_off
+    substr $S10, rx454_tgt, $I11, 5
+    ne $S10, "proto", rx454_fail
+    add rx454_pos, 5
+    goto alt456_end
+  alt456_2:
   # rx literal  "only"
-    add $I11, rx477_pos, 4
-    gt $I11, rx477_eos, rx477_fail
-    sub $I11, rx477_pos, rx477_off
-    substr $S10, rx477_tgt, $I11, 4
-    ne $S10, "only", rx477_fail
-    add rx477_pos, 4
-  alt479_end:
-  # rx pass
-    rx477_cur."!cursor_pass"(rx477_pos, "")
-    rx477_cur."!cursor_debug"("PASS  ", "", " at pos=", rx477_pos)
-    .return (rx477_cur)
-  rx477_fail:
-    (rx477_rep, rx477_pos, $I10, $P10) = rx477_cur."!mark_fail"(0)
-    lt rx477_pos, -1, rx477_done
-    eq rx477_pos, -1, rx477_fail
-    jump $I10
-  rx477_done:
-    rx477_cur."!cursor_fail"()
-    rx477_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx477_cur)
+    add $I11, rx454_pos, 4
+    gt $I11, rx454_eos, rx454_fail
+    sub $I11, rx454_pos, rx454_off
+    substr $S10, rx454_tgt, $I11, 4
+    ne $S10, "only", rx454_fail
+    add rx454_pos, 4
+  alt456_end:
+  # rx pass
+    rx454_cur."!cursor_pass"(rx454_pos, "")
+    rx454_cur."!cursor_debug"("PASS  ", "", " at pos=", rx454_pos)
+    .return (rx454_cur)
+  rx454_restart:
+    rx454_cur."!cursor_debug"("NEXT ", "")
+  rx454_fail:
+    (rx454_rep, rx454_pos, $I10, $P10) = rx454_cur."!mark_fail"(0)
+    lt rx454_pos, -1, rx454_done
+    eq rx454_pos, -1, rx454_fail
+    jump $I10
+  rx454_done:
+    rx454_cur."!cursor_fail"()
+    rx454_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx454_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<regex_declarator>"  :subid("114_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx481_tgt
-    .local int rx481_pos
-    .local int rx481_off
-    .local int rx481_eos
-    .local int rx481_rep
-    .local pmc rx481_cur
-    (rx481_cur, rx481_pos, rx481_tgt) = self."!cursor_start"()
-    rx481_cur."!cursor_debug"("START ", "term:sym<regex_declarator>")
-    .lex unicode:"$\x{a2}", rx481_cur
-    .local pmc match
-    .lex "$/", match
-    length rx481_eos, rx481_tgt
-    gt rx481_pos, rx481_eos, rx481_done
-    set rx481_off, 0
-    lt rx481_pos, 2, rx481_start
-    sub rx481_off, rx481_pos, 1
-    substr rx481_tgt, rx481_tgt, rx481_off
-  rx481_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan485_done
-    goto rxscan485_scan
-  rxscan485_loop:
-    ($P10) = rx481_cur."from"()
-    inc $P10
-    set rx481_pos, $P10
-    ge rx481_pos, rx481_eos, rxscan485_done
-  rxscan485_scan:
-    set_addr $I10, rxscan485_loop
-    rx481_cur."!mark_push"(0, rx481_pos, $I10)
-  rxscan485_done:
+.sub "term:sym<regex_declarator>"  :subid("114_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx458_tgt
+    .local int rx458_pos
+    .local int rx458_off
+    .local int rx458_eos
+    .local int rx458_rep
+    .local pmc rx458_cur
+    (rx458_cur, rx458_pos, rx458_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx458_cur
+    .local pmc match
+    .lex "$/", match
+    length rx458_eos, rx458_tgt
+    gt rx458_pos, rx458_eos, rx458_done
+    set rx458_off, 0
+    lt rx458_pos, 2, rx458_start
+    sub rx458_off, rx458_pos, 1
+    substr rx458_tgt, rx458_tgt, rx458_off
+  rx458_start:
+    eq $I10, 1, rx458_restart
+    rx458_cur."!cursor_debug"("START ", "term:sym<regex_declarator>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan462_done
+    goto rxscan462_scan
+  rxscan462_loop:
+    ($P10) = rx458_cur."from"()
+    inc $P10
+    set rx458_pos, $P10
+    ge rx458_pos, rx458_eos, rxscan462_done
+  rxscan462_scan:
+    set_addr $I10, rxscan462_loop
+    rx458_cur."!mark_push"(0, rx458_pos, $I10)
+  rxscan462_done:
 .annotate 'line', 232
   # rx subrule "regex_declarator" subtype=capture negate=
-    rx481_cur."!cursor_pos"(rx481_pos)
-    $P10 = rx481_cur."regex_declarator"()
-    unless $P10, rx481_fail
-    rx481_cur."!mark_push"(0, -1, 0, $P10)
+    rx458_cur."!cursor_pos"(rx458_pos)
+    $P10 = rx458_cur."regex_declarator"()
+    unless $P10, rx458_fail
+    rx458_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("regex_declarator")
-    rx481_pos = $P10."pos"()
+    rx458_pos = $P10."pos"()
   # rx pass
-    rx481_cur."!cursor_pass"(rx481_pos, "term:sym<regex_declarator>")
-    rx481_cur."!cursor_debug"("PASS  ", "term:sym<regex_declarator>", " at pos=", rx481_pos)
-    .return (rx481_cur)
-  rx481_fail:
+    rx458_cur."!cursor_pass"(rx458_pos, "term:sym<regex_declarator>")
+    rx458_cur."!cursor_debug"("PASS  ", "term:sym<regex_declarator>", " at pos=", rx458_pos)
+    .return (rx458_cur)
+  rx458_restart:
 .annotate 'line', 4
-    (rx481_rep, rx481_pos, $I10, $P10) = rx481_cur."!mark_fail"(0)
-    lt rx481_pos, -1, rx481_done
-    eq rx481_pos, -1, rx481_fail
+    rx458_cur."!cursor_debug"("NEXT ", "term:sym<regex_declarator>")
+  rx458_fail:
+    (rx458_rep, rx458_pos, $I10, $P10) = rx458_cur."!mark_fail"(0)
+    lt rx458_pos, -1, rx458_done
+    eq rx458_pos, -1, rx458_fail
     jump $I10
-  rx481_done:
-    rx481_cur."!cursor_fail"()
-    rx481_cur."!cursor_debug"("FAIL  ", "term:sym<regex_declarator>")
-    .return (rx481_cur)
+  rx458_done:
+    rx458_cur."!cursor_fail"()
+    rx458_cur."!cursor_debug"("FAIL  ", "term:sym<regex_declarator>")
+    .return (rx458_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<regex_declarator>"  :subid("115_1278500537.15927") :method
+.sub "!PREFIX__term:sym<regex_declarator>"  :subid("115_1279529226.73787") :method
 .annotate 'line', 4
-    $P483 = self."!PREFIX__!subrule"("regex_declarator", "")
-    new $P484, "ResizablePMCArray"
-    push $P484, $P483
-    .return ($P484)
+    $P460 = self."!PREFIX__!subrule"("regex_declarator", "")
+    new $P461, "ResizablePMCArray"
+    push $P461, $P460
+    .return ($P461)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<statement_prefix>"  :subid("116_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<statement_prefix>"  :subid("116_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx487_tgt
-    .local int rx487_pos
-    .local int rx487_off
-    .local int rx487_eos
-    .local int rx487_rep
-    .local pmc rx487_cur
-    (rx487_cur, rx487_pos, rx487_tgt) = self."!cursor_start"()
-    rx487_cur."!cursor_debug"("START ", "term:sym<statement_prefix>")
-    .lex unicode:"$\x{a2}", rx487_cur
+    .local string rx464_tgt
+    .local int rx464_pos
+    .local int rx464_off
+    .local int rx464_eos
+    .local int rx464_rep
+    .local pmc rx464_cur
+    (rx464_cur, rx464_pos, rx464_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx464_cur
     .local pmc match
     .lex "$/", match
-    length rx487_eos, rx487_tgt
-    gt rx487_pos, rx487_eos, rx487_done
-    set rx487_off, 0
-    lt rx487_pos, 2, rx487_start
-    sub rx487_off, rx487_pos, 1
-    substr rx487_tgt, rx487_tgt, rx487_off
-  rx487_start:
+    length rx464_eos, rx464_tgt
+    gt rx464_pos, rx464_eos, rx464_done
+    set rx464_off, 0
+    lt rx464_pos, 2, rx464_start
+    sub rx464_off, rx464_pos, 1
+    substr rx464_tgt, rx464_tgt, rx464_off
+  rx464_start:
+    eq $I10, 1, rx464_restart
+    rx464_cur."!cursor_debug"("START ", "term:sym<statement_prefix>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan491_done
-    goto rxscan491_scan
-  rxscan491_loop:
-    ($P10) = rx487_cur."from"()
+    ne $I10, -1, rxscan468_done
+    goto rxscan468_scan
+  rxscan468_loop:
+    ($P10) = rx464_cur."from"()
     inc $P10
-    set rx487_pos, $P10
-    ge rx487_pos, rx487_eos, rxscan491_done
-  rxscan491_scan:
-    set_addr $I10, rxscan491_loop
-    rx487_cur."!mark_push"(0, rx487_pos, $I10)
-  rxscan491_done:
+    set rx464_pos, $P10
+    ge rx464_pos, rx464_eos, rxscan468_done
+  rxscan468_scan:
+    set_addr $I10, rxscan468_loop
+    rx464_cur."!mark_push"(0, rx464_pos, $I10)
+  rxscan468_done:
 .annotate 'line', 233
   # rx subrule "statement_prefix" subtype=capture negate=
-    rx487_cur."!cursor_pos"(rx487_pos)
-    $P10 = rx487_cur."statement_prefix"()
-    unless $P10, rx487_fail
-    rx487_cur."!mark_push"(0, -1, 0, $P10)
+    rx464_cur."!cursor_pos"(rx464_pos)
+    $P10 = rx464_cur."statement_prefix"()
+    unless $P10, rx464_fail
+    rx464_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("statement_prefix")
-    rx487_pos = $P10."pos"()
+    rx464_pos = $P10."pos"()
   # rx pass
-    rx487_cur."!cursor_pass"(rx487_pos, "term:sym<statement_prefix>")
-    rx487_cur."!cursor_debug"("PASS  ", "term:sym<statement_prefix>", " at pos=", rx487_pos)
-    .return (rx487_cur)
-  rx487_fail:
+    rx464_cur."!cursor_pass"(rx464_pos, "term:sym<statement_prefix>")
+    rx464_cur."!cursor_debug"("PASS  ", "term:sym<statement_prefix>", " at pos=", rx464_pos)
+    .return (rx464_cur)
+  rx464_restart:
 .annotate 'line', 4
-    (rx487_rep, rx487_pos, $I10, $P10) = rx487_cur."!mark_fail"(0)
-    lt rx487_pos, -1, rx487_done
-    eq rx487_pos, -1, rx487_fail
+    rx464_cur."!cursor_debug"("NEXT ", "term:sym<statement_prefix>")
+  rx464_fail:
+    (rx464_rep, rx464_pos, $I10, $P10) = rx464_cur."!mark_fail"(0)
+    lt rx464_pos, -1, rx464_done
+    eq rx464_pos, -1, rx464_fail
     jump $I10
-  rx487_done:
-    rx487_cur."!cursor_fail"()
-    rx487_cur."!cursor_debug"("FAIL  ", "term:sym<statement_prefix>")
-    .return (rx487_cur)
+  rx464_done:
+    rx464_cur."!cursor_fail"()
+    rx464_cur."!cursor_debug"("FAIL  ", "term:sym<statement_prefix>")
+    .return (rx464_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<statement_prefix>"  :subid("117_1278500537.15927") :method
+.sub "!PREFIX__term:sym<statement_prefix>"  :subid("117_1279529226.73787") :method
 .annotate 'line', 4
-    $P489 = self."!PREFIX__!subrule"("statement_prefix", "")
-    new $P490, "ResizablePMCArray"
-    push $P490, $P489
-    .return ($P490)
+    $P466 = self."!PREFIX__!subrule"("statement_prefix", "")
+    new $P467, "ResizablePMCArray"
+    push $P467, $P466
+    .return ($P467)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<lambda>"  :subid("118_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<lambda>"  :subid("118_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx493_tgt
-    .local int rx493_pos
-    .local int rx493_off
-    .local int rx493_eos
-    .local int rx493_rep
-    .local pmc rx493_cur
-    (rx493_cur, rx493_pos, rx493_tgt) = self."!cursor_start"()
-    rx493_cur."!cursor_debug"("START ", "term:sym<lambda>")
-    .lex unicode:"$\x{a2}", rx493_cur
+    .local string rx470_tgt
+    .local int rx470_pos
+    .local int rx470_off
+    .local int rx470_eos
+    .local int rx470_rep
+    .local pmc rx470_cur
+    (rx470_cur, rx470_pos, rx470_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx470_cur
     .local pmc match
     .lex "$/", match
-    length rx493_eos, rx493_tgt
-    gt rx493_pos, rx493_eos, rx493_done
-    set rx493_off, 0
-    lt rx493_pos, 2, rx493_start
-    sub rx493_off, rx493_pos, 1
-    substr rx493_tgt, rx493_tgt, rx493_off
-  rx493_start:
+    length rx470_eos, rx470_tgt
+    gt rx470_pos, rx470_eos, rx470_done
+    set rx470_off, 0
+    lt rx470_pos, 2, rx470_start
+    sub rx470_off, rx470_pos, 1
+    substr rx470_tgt, rx470_tgt, rx470_off
+  rx470_start:
+    eq $I10, 1, rx470_restart
+    rx470_cur."!cursor_debug"("START ", "term:sym<lambda>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan496_done
-    goto rxscan496_scan
-  rxscan496_loop:
-    ($P10) = rx493_cur."from"()
+    ne $I10, -1, rxscan473_done
+    goto rxscan473_scan
+  rxscan473_loop:
+    ($P10) = rx470_cur."from"()
     inc $P10
-    set rx493_pos, $P10
-    ge rx493_pos, rx493_eos, rxscan496_done
-  rxscan496_scan:
-    set_addr $I10, rxscan496_loop
-    rx493_cur."!mark_push"(0, rx493_pos, $I10)
-  rxscan496_done:
+    set rx470_pos, $P10
+    ge rx470_pos, rx470_eos, rxscan473_done
+  rxscan473_scan:
+    set_addr $I10, rxscan473_loop
+    rx470_cur."!mark_push"(0, rx470_pos, $I10)
+  rxscan473_done:
 .annotate 'line', 234
   # rx subrule "lambda" subtype=zerowidth negate=
-    rx493_cur."!cursor_pos"(rx493_pos)
-    $P10 = rx493_cur."lambda"()
-    unless $P10, rx493_fail
+    rx470_cur."!cursor_pos"(rx470_pos)
+    $P10 = rx470_cur."lambda"()
+    unless $P10, rx470_fail
   # rx subrule "pblock" subtype=capture negate=
-    rx493_cur."!cursor_pos"(rx493_pos)
-    $P10 = rx493_cur."pblock"()
-    unless $P10, rx493_fail
-    rx493_cur."!mark_push"(0, -1, 0, $P10)
+    rx470_cur."!cursor_pos"(rx470_pos)
+    $P10 = rx470_cur."pblock"()
+    unless $P10, rx470_fail
+    rx470_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("pblock")
-    rx493_pos = $P10."pos"()
+    rx470_pos = $P10."pos"()
   # rx pass
-    rx493_cur."!cursor_pass"(rx493_pos, "term:sym<lambda>")
-    rx493_cur."!cursor_debug"("PASS  ", "term:sym<lambda>", " at pos=", rx493_pos)
-    .return (rx493_cur)
-  rx493_fail:
+    rx470_cur."!cursor_pass"(rx470_pos, "term:sym<lambda>")
+    rx470_cur."!cursor_debug"("PASS  ", "term:sym<lambda>", " at pos=", rx470_pos)
+    .return (rx470_cur)
+  rx470_restart:
 .annotate 'line', 4
-    (rx493_rep, rx493_pos, $I10, $P10) = rx493_cur."!mark_fail"(0)
-    lt rx493_pos, -1, rx493_done
-    eq rx493_pos, -1, rx493_fail
+    rx470_cur."!cursor_debug"("NEXT ", "term:sym<lambda>")
+  rx470_fail:
+    (rx470_rep, rx470_pos, $I10, $P10) = rx470_cur."!mark_fail"(0)
+    lt rx470_pos, -1, rx470_done
+    eq rx470_pos, -1, rx470_fail
     jump $I10
-  rx493_done:
-    rx493_cur."!cursor_fail"()
-    rx493_cur."!cursor_debug"("FAIL  ", "term:sym<lambda>")
-    .return (rx493_cur)
+  rx470_done:
+    rx470_cur."!cursor_fail"()
+    rx470_cur."!cursor_debug"("FAIL  ", "term:sym<lambda>")
+    .return (rx470_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<lambda>"  :subid("119_1278500537.15927") :method
+.sub "!PREFIX__term:sym<lambda>"  :subid("119_1279529226.73787") :method
 .annotate 'line', 4
-    new $P495, "ResizablePMCArray"
-    push $P495, ""
-    .return ($P495)
+    new $P472, "ResizablePMCArray"
+    push $P472, ""
+    .return ($P472)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "fatarrow"  :subid("120_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "fatarrow"  :subid("120_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx498_tgt
-    .local int rx498_pos
-    .local int rx498_off
-    .local int rx498_eos
-    .local int rx498_rep
-    .local pmc rx498_cur
-    (rx498_cur, rx498_pos, rx498_tgt) = self."!cursor_start"()
-    rx498_cur."!cursor_debug"("START ", "fatarrow")
-    .lex unicode:"$\x{a2}", rx498_cur
+    .local string rx475_tgt
+    .local int rx475_pos
+    .local int rx475_off
+    .local int rx475_eos
+    .local int rx475_rep
+    .local pmc rx475_cur
+    (rx475_cur, rx475_pos, rx475_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx475_cur
     .local pmc match
     .lex "$/", match
-    length rx498_eos, rx498_tgt
-    gt rx498_pos, rx498_eos, rx498_done
-    set rx498_off, 0
-    lt rx498_pos, 2, rx498_start
-    sub rx498_off, rx498_pos, 1
-    substr rx498_tgt, rx498_tgt, rx498_off
-  rx498_start:
+    length rx475_eos, rx475_tgt
+    gt rx475_pos, rx475_eos, rx475_done
+    set rx475_off, 0
+    lt rx475_pos, 2, rx475_start
+    sub rx475_off, rx475_pos, 1
+    substr rx475_tgt, rx475_tgt, rx475_off
+  rx475_start:
+    eq $I10, 1, rx475_restart
+    rx475_cur."!cursor_debug"("START ", "fatarrow")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan502_done
-    goto rxscan502_scan
-  rxscan502_loop:
-    ($P10) = rx498_cur."from"()
+    ne $I10, -1, rxscan479_done
+    goto rxscan479_scan
+  rxscan479_loop:
+    ($P10) = rx475_cur."from"()
     inc $P10
-    set rx498_pos, $P10
-    ge rx498_pos, rx498_eos, rxscan502_done
-  rxscan502_scan:
-    set_addr $I10, rxscan502_loop
-    rx498_cur."!mark_push"(0, rx498_pos, $I10)
-  rxscan502_done:
+    set rx475_pos, $P10
+    ge rx475_pos, rx475_eos, rxscan479_done
+  rxscan479_scan:
+    set_addr $I10, rxscan479_loop
+    rx475_cur."!mark_push"(0, rx475_pos, $I10)
+  rxscan479_done:
 .annotate 'line', 237
   # rx subrule "identifier" subtype=capture negate=
-    rx498_cur."!cursor_pos"(rx498_pos)
-    $P10 = rx498_cur."identifier"()
-    unless $P10, rx498_fail
-    rx498_cur."!mark_push"(0, -1, 0, $P10)
+    rx475_cur."!cursor_pos"(rx475_pos)
+    $P10 = rx475_cur."identifier"()
+    unless $P10, rx475_fail
+    rx475_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("key")
-    rx498_pos = $P10."pos"()
-  # rx rxquantr503 ** 0..*
-    set_addr $I504, rxquantr503_done
-    rx498_cur."!mark_push"(0, rx498_pos, $I504)
-  rxquantr503_loop:
+    rx475_pos = $P10."pos"()
+  # rx rxquantr480 ** 0..*
+    set_addr $I10, rxquantr480_done
+    rx475_cur."!mark_push"(0, rx475_pos, $I10)
+  rxquantr480_loop:
   # rx enumcharlist negate=0 
-    ge rx498_pos, rx498_eos, rx498_fail
-    sub $I10, rx498_pos, rx498_off
-    substr $S10, rx498_tgt, $I10, 1
+    ge rx475_pos, rx475_eos, rx475_fail
+    sub $I10, rx475_pos, rx475_off
+    substr $S10, rx475_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx498_fail
-    inc rx498_pos
-    (rx498_rep) = rx498_cur."!mark_commit"($I504)
-    rx498_cur."!mark_push"(rx498_rep, rx498_pos, $I504)
-    goto rxquantr503_loop
-  rxquantr503_done:
+    lt $I11, 0, rx475_fail
+    inc rx475_pos
+    set_addr $I10, rxquantr480_done
+    (rx475_rep) = rx475_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr480_done
+    rx475_cur."!mark_push"(rx475_rep, rx475_pos, $I10)
+    goto rxquantr480_loop
+  rxquantr480_done:
   # rx literal  "=>"
-    add $I11, rx498_pos, 2
-    gt $I11, rx498_eos, rx498_fail
-    sub $I11, rx498_pos, rx498_off
-    substr $S10, rx498_tgt, $I11, 2
-    ne $S10, "=>", rx498_fail
-    add rx498_pos, 2
-  # rx subrule "ws" subtype=method negate=
-    rx498_cur."!cursor_pos"(rx498_pos)
-    $P10 = rx498_cur."ws"()
-    unless $P10, rx498_fail
-    rx498_pos = $P10."pos"()
+    add $I11, rx475_pos, 2
+    gt $I11, rx475_eos, rx475_fail
+    sub $I11, rx475_pos, rx475_off
+    substr $S10, rx475_tgt, $I11, 2
+    ne $S10, "=>", rx475_fail
+    add rx475_pos, 2
+  # rx subrule "ws" subtype=method negate=
+    rx475_cur."!cursor_pos"(rx475_pos)
+    $P10 = rx475_cur."ws"()
+    unless $P10, rx475_fail
+    rx475_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx498_cur."!cursor_pos"(rx498_pos)
-    $P10 = rx498_cur."EXPR"("i=")
-    unless $P10, rx498_fail
-    rx498_cur."!mark_push"(0, -1, 0, $P10)
+    rx475_cur."!cursor_pos"(rx475_pos)
+    $P10 = rx475_cur."EXPR"("i=")
+    unless $P10, rx475_fail
+    rx475_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("val")
-    rx498_pos = $P10."pos"()
+    rx475_pos = $P10."pos"()
 .annotate 'line', 236
   # rx pass
-    rx498_cur."!cursor_pass"(rx498_pos, "fatarrow")
-    rx498_cur."!cursor_debug"("PASS  ", "fatarrow", " at pos=", rx498_pos)
-    .return (rx498_cur)
-  rx498_fail:
+    rx475_cur."!cursor_pass"(rx475_pos, "fatarrow")
+    rx475_cur."!cursor_debug"("PASS  ", "fatarrow", " at pos=", rx475_pos)
+    .return (rx475_cur)
+  rx475_restart:
 .annotate 'line', 4
-    (rx498_rep, rx498_pos, $I10, $P10) = rx498_cur."!mark_fail"(0)
-    lt rx498_pos, -1, rx498_done
-    eq rx498_pos, -1, rx498_fail
+    rx475_cur."!cursor_debug"("NEXT ", "fatarrow")
+  rx475_fail:
+    (rx475_rep, rx475_pos, $I10, $P10) = rx475_cur."!mark_fail"(0)
+    lt rx475_pos, -1, rx475_done
+    eq rx475_pos, -1, rx475_fail
     jump $I10
-  rx498_done:
-    rx498_cur."!cursor_fail"()
-    rx498_cur."!cursor_debug"("FAIL  ", "fatarrow")
-    .return (rx498_cur)
+  rx475_done:
+    rx475_cur."!cursor_fail"()
+    rx475_cur."!cursor_debug"("FAIL  ", "fatarrow")
+    .return (rx475_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__fatarrow"  :subid("121_1278500537.15927") :method
+.sub "!PREFIX__fatarrow"  :subid("121_1279529226.73787") :method
 .annotate 'line', 4
-    $P500 = self."!PREFIX__!subrule"("identifier", "")
-    new $P501, "ResizablePMCArray"
-    push $P501, $P500
-    .return ($P501)
+    $P477 = self."!PREFIX__!subrule"("identifier", "")
+    new $P478, "ResizablePMCArray"
+    push $P478, $P477
+    .return ($P478)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "colonpair"  :subid("122_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "colonpair"  :subid("122_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx506_tgt
-    .local int rx506_pos
-    .local int rx506_off
-    .local int rx506_eos
-    .local int rx506_rep
-    .local pmc rx506_cur
-    (rx506_cur, rx506_pos, rx506_tgt) = self."!cursor_start"()
-    rx506_cur."!cursor_debug"("START ", "colonpair")
-    rx506_cur."!cursor_caparray"("circumfix")
-    .lex unicode:"$\x{a2}", rx506_cur
+    .local string rx482_tgt
+    .local int rx482_pos
+    .local int rx482_off
+    .local int rx482_eos
+    .local int rx482_rep
+    .local pmc rx482_cur
+    (rx482_cur, rx482_pos, rx482_tgt, $I10) = self."!cursor_start"()
+    rx482_cur."!cursor_caparray"("circumfix")
+    .lex unicode:"$\x{a2}", rx482_cur
     .local pmc match
     .lex "$/", match
-    length rx506_eos, rx506_tgt
-    gt rx506_pos, rx506_eos, rx506_done
-    set rx506_off, 0
-    lt rx506_pos, 2, rx506_start
-    sub rx506_off, rx506_pos, 1
-    substr rx506_tgt, rx506_tgt, rx506_off
-  rx506_start:
+    length rx482_eos, rx482_tgt
+    gt rx482_pos, rx482_eos, rx482_done
+    set rx482_off, 0
+    lt rx482_pos, 2, rx482_start
+    sub rx482_off, rx482_pos, 1
+    substr rx482_tgt, rx482_tgt, rx482_off
+  rx482_start:
+    eq $I10, 1, rx482_restart
+    rx482_cur."!cursor_debug"("START ", "colonpair")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan512_done
-    goto rxscan512_scan
-  rxscan512_loop:
-    ($P10) = rx506_cur."from"()
+    ne $I10, -1, rxscan488_done
+    goto rxscan488_scan
+  rxscan488_loop:
+    ($P10) = rx482_cur."from"()
     inc $P10
-    set rx506_pos, $P10
-    ge rx506_pos, rx506_eos, rxscan512_done
-  rxscan512_scan:
-    set_addr $I10, rxscan512_loop
-    rx506_cur."!mark_push"(0, rx506_pos, $I10)
-  rxscan512_done:
+    set rx482_pos, $P10
+    ge rx482_pos, rx482_eos, rxscan488_done
+  rxscan488_scan:
+    set_addr $I10, rxscan488_loop
+    rx482_cur."!mark_push"(0, rx482_pos, $I10)
+  rxscan488_done:
 .annotate 'line', 241
   # rx literal  ":"
-    add $I11, rx506_pos, 1
-    gt $I11, rx506_eos, rx506_fail
-    sub $I11, rx506_pos, rx506_off
-    substr $S10, rx506_tgt, $I11, 1
-    ne $S10, ":", rx506_fail
-    add rx506_pos, 1
-  alt513_0:
+    add $I11, rx482_pos, 1
+    gt $I11, rx482_eos, rx482_fail
+    sub $I11, rx482_pos, rx482_off
+    substr $S10, rx482_tgt, $I11, 1
+    ne $S10, ":", rx482_fail
+    add rx482_pos, 1
+  alt489_0:
 .annotate 'line', 242
-    set_addr $I10, alt513_1
-    rx506_cur."!mark_push"(0, rx506_pos, $I10)
+    set_addr $I10, alt489_1
+    rx482_cur."!mark_push"(0, rx482_pos, $I10)
 .annotate 'line', 243
   # rx subcapture "not"
-    set_addr $I10, rxcap_514_fail
-    rx506_cur."!mark_push"(0, rx506_pos, $I10)
+    set_addr $I10, rxcap_490_fail
+    rx482_cur."!mark_push"(0, rx482_pos, $I10)
   # rx literal  "!"
-    add $I11, rx506_pos, 1
-    gt $I11, rx506_eos, rx506_fail
-    sub $I11, rx506_pos, rx506_off
-    substr $S10, rx506_tgt, $I11, 1
-    ne $S10, "!", rx506_fail
-    add rx506_pos, 1
-    set_addr $I10, rxcap_514_fail
-    ($I12, $I11) = rx506_cur."!mark_peek"($I10)
-    rx506_cur."!cursor_pos"($I11)
-    ($P10) = rx506_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx506_pos, "")
-    rx506_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx482_pos, 1
+    gt $I11, rx482_eos, rx482_fail
+    sub $I11, rx482_pos, rx482_off
+    substr $S10, rx482_tgt, $I11, 1
+    ne $S10, "!", rx482_fail
+    add rx482_pos, 1
+    set_addr $I10, rxcap_490_fail
+    ($I12, $I11) = rx482_cur."!mark_peek"($I10)
+    rx482_cur."!cursor_pos"($I11)
+    ($P10) = rx482_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx482_pos, "")
+    rx482_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("not")
-    goto rxcap_514_done
-  rxcap_514_fail:
-    goto rx506_fail
-  rxcap_514_done:
+    goto rxcap_490_done
+  rxcap_490_fail:
+    goto rx482_fail
+  rxcap_490_done:
   # rx subrule "identifier" subtype=capture negate=
-    rx506_cur."!cursor_pos"(rx506_pos)
-    $P10 = rx506_cur."identifier"()
-    unless $P10, rx506_fail
-    rx506_cur."!mark_push"(0, -1, 0, $P10)
+    rx482_cur."!cursor_pos"(rx482_pos)
+    $P10 = rx482_cur."identifier"()
+    unless $P10, rx482_fail
+    rx482_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("identifier")
-    rx506_pos = $P10."pos"()
-    goto alt513_end
-  alt513_1:
-    set_addr $I10, alt513_2
-    rx506_cur."!mark_push"(0, rx506_pos, $I10)
+    rx482_pos = $P10."pos"()
+    goto alt489_end
+  alt489_1:
+    set_addr $I10, alt489_2
+    rx482_cur."!mark_push"(0, rx482_pos, $I10)
 .annotate 'line', 244
   # rx subrule "identifier" subtype=capture negate=
-    rx506_cur."!cursor_pos"(rx506_pos)
-    $P10 = rx506_cur."identifier"()
-    unless $P10, rx506_fail
-    rx506_cur."!mark_push"(0, -1, 0, $P10)
+    rx482_cur."!cursor_pos"(rx482_pos)
+    $P10 = rx482_cur."identifier"()
+    unless $P10, rx482_fail
+    rx482_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("identifier")
-    rx506_pos = $P10."pos"()
-  # rx rxquantr515 ** 0..1
-    set_addr $I516, rxquantr515_done
-    rx506_cur."!mark_push"(0, rx506_pos, $I516)
-  rxquantr515_loop:
+    rx482_pos = $P10."pos"()
+  # rx rxquantr491 ** 0..1
+    set_addr $I10, rxquantr491_done
+    rx482_cur."!mark_push"(0, rx482_pos, $I10)
+  rxquantr491_loop:
   # rx subrule "circumfix" subtype=capture negate=
-    rx506_cur."!cursor_pos"(rx506_pos)
-    $P10 = rx506_cur."circumfix"()
-    unless $P10, rx506_fail
-    rx506_cur."!mark_push"(0, -1, 0, $P10)
+    rx482_cur."!cursor_pos"(rx482_pos)
+    $P10 = rx482_cur."circumfix"()
+    unless $P10, rx482_fail
+    goto rxsubrule492_pass
+  rxsubrule492_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx482_fail
+  rxsubrule492_pass:
+    set_addr $I10, rxsubrule492_back
+    rx482_cur."!mark_push"(0, rx482_pos, $I10, $P10)
     $P10."!cursor_names"("circumfix")
-    rx506_pos = $P10."pos"()
-    (rx506_rep) = rx506_cur."!mark_commit"($I516)
-  rxquantr515_done:
-    goto alt513_end
-  alt513_2:
+    rx482_pos = $P10."pos"()
+    set_addr $I10, rxquantr491_done
+    (rx482_rep) = rx482_cur."!mark_commit"($I10)
+  rxquantr491_done:
+    goto alt489_end
+  alt489_2:
 .annotate 'line', 245
   # rx subrule "circumfix" subtype=capture negate=
-    rx506_cur."!cursor_pos"(rx506_pos)
-    $P10 = rx506_cur."circumfix"()
-    unless $P10, rx506_fail
-    rx506_cur."!mark_push"(0, -1, 0, $P10)
+    rx482_cur."!cursor_pos"(rx482_pos)
+    $P10 = rx482_cur."circumfix"()
+    unless $P10, rx482_fail
+    rx482_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("circumfix")
-    rx506_pos = $P10."pos"()
-  alt513_end:
+    rx482_pos = $P10."pos"()
+  alt489_end:
 .annotate 'line', 240
   # rx pass
-    rx506_cur."!cursor_pass"(rx506_pos, "colonpair")
-    rx506_cur."!cursor_debug"("PASS  ", "colonpair", " at pos=", rx506_pos)
-    .return (rx506_cur)
-  rx506_fail:
-.annotate 'line', 4
-    (rx506_rep, rx506_pos, $I10, $P10) = rx506_cur."!mark_fail"(0)
-    lt rx506_pos, -1, rx506_done
-    eq rx506_pos, -1, rx506_fail
-    jump $I10
-  rx506_done:
-    rx506_cur."!cursor_fail"()
-    rx506_cur."!cursor_debug"("FAIL  ", "colonpair")
-    .return (rx506_cur)
+    rx482_cur."!cursor_pass"(rx482_pos, "colonpair")
+    rx482_cur."!cursor_debug"("PASS  ", "colonpair", " at pos=", rx482_pos)
+    .return (rx482_cur)
+  rx482_restart:
+.annotate 'line', 4
+    rx482_cur."!cursor_debug"("NEXT ", "colonpair")
+  rx482_fail:
+    (rx482_rep, rx482_pos, $I10, $P10) = rx482_cur."!mark_fail"(0)
+    lt rx482_pos, -1, rx482_done
+    eq rx482_pos, -1, rx482_fail
+    jump $I10
+  rx482_done:
+    rx482_cur."!cursor_fail"()
+    rx482_cur."!cursor_debug"("FAIL  ", "colonpair")
+    .return (rx482_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__colonpair"  :subid("123_1278500537.15927") :method
-.annotate 'line', 4
-    $P508 = self."!PREFIX__!subrule"("circumfix", ":")
-    $P509 = self."!PREFIX__!subrule"("identifier", ":")
-    $P510 = self."!PREFIX__!subrule"("identifier", ":!")
-    new $P511, "ResizablePMCArray"
-    push $P511, $P508
-    push $P511, $P509
-    push $P511, $P510
-    .return ($P511)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "variable"  :subid("124_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx518_tgt
-    .local int rx518_pos
-    .local int rx518_off
-    .local int rx518_eos
-    .local int rx518_rep
-    .local pmc rx518_cur
-    (rx518_cur, rx518_pos, rx518_tgt) = self."!cursor_start"()
-    rx518_cur."!cursor_debug"("START ", "variable")
-    rx518_cur."!cursor_caparray"("twigil")
-    .lex unicode:"$\x{a2}", rx518_cur
-    .local pmc match
-    .lex "$/", match
-    length rx518_eos, rx518_tgt
-    gt rx518_pos, rx518_eos, rx518_done
-    set rx518_off, 0
-    lt rx518_pos, 2, rx518_start
-    sub rx518_off, rx518_pos, 1
-    substr rx518_tgt, rx518_tgt, rx518_off
-  rx518_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan523_done
-    goto rxscan523_scan
-  rxscan523_loop:
-    ($P10) = rx518_cur."from"()
-    inc $P10
-    set rx518_pos, $P10
-    ge rx518_pos, rx518_eos, rxscan523_done
-  rxscan523_scan:
-    set_addr $I10, rxscan523_loop
-    rx518_cur."!mark_push"(0, rx518_pos, $I10)
-  rxscan523_done:
-  alt524_0:
+.sub "!PREFIX__colonpair"  :subid("123_1279529226.73787") :method
+.annotate 'line', 4
+    $P484 = self."!PREFIX__!subrule"("circumfix", ":")
+    $P485 = self."!PREFIX__!subrule"("identifier", ":")
+    $P486 = self."!PREFIX__!subrule"("identifier", ":!")
+    new $P487, "ResizablePMCArray"
+    push $P487, $P484
+    push $P487, $P485
+    push $P487, $P486
+    .return ($P487)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "variable"  :subid("124_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx494_tgt
+    .local int rx494_pos
+    .local int rx494_off
+    .local int rx494_eos
+    .local int rx494_rep
+    .local pmc rx494_cur
+    (rx494_cur, rx494_pos, rx494_tgt, $I10) = self."!cursor_start"()
+    rx494_cur."!cursor_caparray"("twigil")
+    .lex unicode:"$\x{a2}", rx494_cur
+    .local pmc match
+    .lex "$/", match
+    length rx494_eos, rx494_tgt
+    gt rx494_pos, rx494_eos, rx494_done
+    set rx494_off, 0
+    lt rx494_pos, 2, rx494_start
+    sub rx494_off, rx494_pos, 1
+    substr rx494_tgt, rx494_tgt, rx494_off
+  rx494_start:
+    eq $I10, 1, rx494_restart
+    rx494_cur."!cursor_debug"("START ", "variable")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan499_done
+    goto rxscan499_scan
+  rxscan499_loop:
+    ($P10) = rx494_cur."from"()
+    inc $P10
+    set rx494_pos, $P10
+    ge rx494_pos, rx494_eos, rxscan499_done
+  rxscan499_scan:
+    set_addr $I10, rxscan499_loop
+    rx494_cur."!mark_push"(0, rx494_pos, $I10)
+  rxscan499_done:
+  alt500_0:
 .annotate 'line', 249
-    set_addr $I10, alt524_1
-    rx518_cur."!mark_push"(0, rx518_pos, $I10)
+    set_addr $I10, alt500_1
+    rx494_cur."!mark_push"(0, rx494_pos, $I10)
 .annotate 'line', 250
   # rx subrule "sigil" subtype=capture negate=
-    rx518_cur."!cursor_pos"(rx518_pos)
-    $P10 = rx518_cur."sigil"()
-    unless $P10, rx518_fail
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    rx494_cur."!cursor_pos"(rx494_pos)
+    $P10 = rx494_cur."sigil"()
+    unless $P10, rx494_fail
+    rx494_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sigil")
-    rx518_pos = $P10."pos"()
-  # rx rxquantr525 ** 0..1
-    set_addr $I526, rxquantr525_done
-    rx518_cur."!mark_push"(0, rx518_pos, $I526)
-  rxquantr525_loop:
+    rx494_pos = $P10."pos"()
+  # rx rxquantr501 ** 0..1
+    set_addr $I10, rxquantr501_done
+    rx494_cur."!mark_push"(0, rx494_pos, $I10)
+  rxquantr501_loop:
   # rx subrule "twigil" subtype=capture negate=
-    rx518_cur."!cursor_pos"(rx518_pos)
-    $P10 = rx518_cur."twigil"()
-    unless $P10, rx518_fail
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    rx494_cur."!cursor_pos"(rx494_pos)
+    $P10 = rx494_cur."twigil"()
+    unless $P10, rx494_fail
+    goto rxsubrule502_pass
+  rxsubrule502_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx494_fail
+  rxsubrule502_pass:
+    set_addr $I10, rxsubrule502_back
+    rx494_cur."!mark_push"(0, rx494_pos, $I10, $P10)
     $P10."!cursor_names"("twigil")
-    rx518_pos = $P10."pos"()
-    (rx518_rep) = rx518_cur."!mark_commit"($I526)
-  rxquantr525_done:
+    rx494_pos = $P10."pos"()
+    set_addr $I10, rxquantr501_done
+    (rx494_rep) = rx494_cur."!mark_commit"($I10)
+  rxquantr501_done:
   # rx subrule "name" subtype=capture negate=
-    rx518_cur."!cursor_pos"(rx518_pos)
-    $P10 = rx518_cur."name"()
-    unless $P10, rx518_fail
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    rx494_cur."!cursor_pos"(rx494_pos)
+    $P10 = rx494_cur."name"()
+    unless $P10, rx494_fail
+    rx494_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("desigilname")
-    rx518_pos = $P10."pos"()
-    goto alt524_end
-  alt524_1:
-    set_addr $I10, alt524_2
-    rx518_cur."!mark_push"(0, rx518_pos, $I10)
+    rx494_pos = $P10."pos"()
+    goto alt500_end
+  alt500_1:
+    set_addr $I10, alt500_2
+    rx494_cur."!mark_push"(0, rx494_pos, $I10)
 .annotate 'line', 251
   # rx subrule "sigil" subtype=capture negate=
-    rx518_cur."!cursor_pos"(rx518_pos)
-    $P10 = rx518_cur."sigil"()
-    unless $P10, rx518_fail
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    rx494_cur."!cursor_pos"(rx494_pos)
+    $P10 = rx494_cur."sigil"()
+    unless $P10, rx494_fail
+    rx494_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sigil")
-    rx518_pos = $P10."pos"()
+    rx494_pos = $P10."pos"()
   # rx enumcharlist negate=0 zerowidth
-    ge rx518_pos, rx518_eos, rx518_fail
-    sub $I10, rx518_pos, rx518_off
-    substr $S10, rx518_tgt, $I10, 1
+    ge rx494_pos, rx494_eos, rx494_fail
+    sub $I10, rx494_pos, rx494_off
+    substr $S10, rx494_tgt, $I10, 1
     index $I11, "<[", $S10
-    lt $I11, 0, rx518_fail
+    lt $I11, 0, rx494_fail
   # rx subrule "postcircumfix" subtype=capture negate=
-    rx518_cur."!cursor_pos"(rx518_pos)
-    $P10 = rx518_cur."postcircumfix"()
-    unless $P10, rx518_fail
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    rx494_cur."!cursor_pos"(rx494_pos)
+    $P10 = rx494_cur."postcircumfix"()
+    unless $P10, rx494_fail
+    rx494_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("postcircumfix")
-    rx518_pos = $P10."pos"()
-    goto alt524_end
-  alt524_2:
+    rx494_pos = $P10."pos"()
+    goto alt500_end
+  alt500_2:
 .annotate 'line', 252
   # rx subcapture "sigil"
-    set_addr $I10, rxcap_527_fail
-    rx518_cur."!mark_push"(0, rx518_pos, $I10)
+    set_addr $I10, rxcap_503_fail
+    rx494_cur."!mark_push"(0, rx494_pos, $I10)
   # rx literal  "$"
-    add $I11, rx518_pos, 1
-    gt $I11, rx518_eos, rx518_fail
-    sub $I11, rx518_pos, rx518_off
-    substr $S10, rx518_tgt, $I11, 1
-    ne $S10, "$", rx518_fail
-    add rx518_pos, 1
-    set_addr $I10, rxcap_527_fail
-    ($I12, $I11) = rx518_cur."!mark_peek"($I10)
-    rx518_cur."!cursor_pos"($I11)
-    ($P10) = rx518_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx518_pos, "")
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx494_pos, 1
+    gt $I11, rx494_eos, rx494_fail
+    sub $I11, rx494_pos, rx494_off
+    substr $S10, rx494_tgt, $I11, 1
+    ne $S10, "$", rx494_fail
+    add rx494_pos, 1
+    set_addr $I10, rxcap_503_fail
+    ($I12, $I11) = rx494_cur."!mark_peek"($I10)
+    rx494_cur."!cursor_pos"($I11)
+    ($P10) = rx494_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx494_pos, "")
+    rx494_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sigil")
-    goto rxcap_527_done
-  rxcap_527_fail:
-    goto rx518_fail
-  rxcap_527_done:
+    goto rxcap_503_done
+  rxcap_503_fail:
+    goto rx494_fail
+  rxcap_503_done:
   # rx subcapture "desigilname"
-    set_addr $I10, rxcap_528_fail
-    rx518_cur."!mark_push"(0, rx518_pos, $I10)
+    set_addr $I10, rxcap_504_fail
+    rx494_cur."!mark_push"(0, rx494_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx518_pos, rx518_eos, rx518_fail
-    sub $I10, rx518_pos, rx518_off
-    substr $S10, rx518_tgt, $I10, 1
+    ge rx494_pos, rx494_eos, rx494_fail
+    sub $I10, rx494_pos, rx494_off
+    substr $S10, rx494_tgt, $I10, 1
     index $I11, "/_!", $S10
-    lt $I11, 0, rx518_fail
-    inc rx518_pos
-    set_addr $I10, rxcap_528_fail
-    ($I12, $I11) = rx518_cur."!mark_peek"($I10)
-    rx518_cur."!cursor_pos"($I11)
-    ($P10) = rx518_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx518_pos, "")
-    rx518_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx494_fail
+    inc rx494_pos
+    set_addr $I10, rxcap_504_fail
+    ($I12, $I11) = rx494_cur."!mark_peek"($I10)
+    rx494_cur."!cursor_pos"($I11)
+    ($P10) = rx494_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx494_pos, "")
+    rx494_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("desigilname")
-    goto rxcap_528_done
-  rxcap_528_fail:
-    goto rx518_fail
-  rxcap_528_done:
-  alt524_end:
+    goto rxcap_504_done
+  rxcap_504_fail:
+    goto rx494_fail
+  rxcap_504_done:
+  alt500_end:
 .annotate 'line', 249
   # rx pass
-    rx518_cur."!cursor_pass"(rx518_pos, "variable")
-    rx518_cur."!cursor_debug"("PASS  ", "variable", " at pos=", rx518_pos)
-    .return (rx518_cur)
-  rx518_fail:
+    rx494_cur."!cursor_pass"(rx494_pos, "variable")
+    rx494_cur."!cursor_debug"("PASS  ", "variable", " at pos=", rx494_pos)
+    .return (rx494_cur)
+  rx494_restart:
 .annotate 'line', 4
-    (rx518_rep, rx518_pos, $I10, $P10) = rx518_cur."!mark_fail"(0)
-    lt rx518_pos, -1, rx518_done
-    eq rx518_pos, -1, rx518_fail
+    rx494_cur."!cursor_debug"("NEXT ", "variable")
+  rx494_fail:
+    (rx494_rep, rx494_pos, $I10, $P10) = rx494_cur."!mark_fail"(0)
+    lt rx494_pos, -1, rx494_done
+    eq rx494_pos, -1, rx494_fail
     jump $I10
-  rx518_done:
-    rx518_cur."!cursor_fail"()
-    rx518_cur."!cursor_debug"("FAIL  ", "variable")
-    .return (rx518_cur)
+  rx494_done:
+    rx494_cur."!cursor_fail"()
+    rx494_cur."!cursor_debug"("FAIL  ", "variable")
+    .return (rx494_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__variable"  :subid("125_1278500537.15927") :method
+.sub "!PREFIX__variable"  :subid("125_1279529226.73787") :method
 .annotate 'line', 4
-    $P520 = self."!PREFIX__!subrule"("sigil", "")
-    $P521 = self."!PREFIX__!subrule"("sigil", "")
-    new $P522, "ResizablePMCArray"
-    push $P522, "$!"
-    push $P522, "$_"
-    push $P522, "$/"
-    push $P522, $P520
-    push $P522, $P521
-    .return ($P522)
+    $P496 = self."!PREFIX__!subrule"("sigil", "")
+    $P497 = self."!PREFIX__!subrule"("sigil", "")
+    new $P498, "ResizablePMCArray"
+    push $P498, "$!"
+    push $P498, "$_"
+    push $P498, "$/"
+    push $P498, $P496
+    push $P498, $P497
+    .return ($P498)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "sigil"  :subid("126_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "sigil"  :subid("126_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx530_tgt
-    .local int rx530_pos
-    .local int rx530_off
-    .local int rx530_eos
-    .local int rx530_rep
-    .local pmc rx530_cur
-    (rx530_cur, rx530_pos, rx530_tgt) = self."!cursor_start"()
-    rx530_cur."!cursor_debug"("START ", "sigil")
-    .lex unicode:"$\x{a2}", rx530_cur
-    .local pmc match
-    .lex "$/", match
-    length rx530_eos, rx530_tgt
-    gt rx530_pos, rx530_eos, rx530_done
-    set rx530_off, 0
-    lt rx530_pos, 2, rx530_start
-    sub rx530_off, rx530_pos, 1
-    substr rx530_tgt, rx530_tgt, rx530_off
-  rx530_start:
+    .local string rx506_tgt
+    .local int rx506_pos
+    .local int rx506_off
+    .local int rx506_eos
+    .local int rx506_rep
+    .local pmc rx506_cur
+    (rx506_cur, rx506_pos, rx506_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx506_cur
+    .local pmc match
+    .lex "$/", match
+    length rx506_eos, rx506_tgt
+    gt rx506_pos, rx506_eos, rx506_done
+    set rx506_off, 0
+    lt rx506_pos, 2, rx506_start
+    sub rx506_off, rx506_pos, 1
+    substr rx506_tgt, rx506_tgt, rx506_off
+  rx506_start:
+    eq $I10, 1, rx506_restart
+    rx506_cur."!cursor_debug"("START ", "sigil")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan533_done
-    goto rxscan533_scan
-  rxscan533_loop:
-    ($P10) = rx530_cur."from"()
+    ne $I10, -1, rxscan509_done
+    goto rxscan509_scan
+  rxscan509_loop:
+    ($P10) = rx506_cur."from"()
     inc $P10
-    set rx530_pos, $P10
-    ge rx530_pos, rx530_eos, rxscan533_done
-  rxscan533_scan:
-    set_addr $I10, rxscan533_loop
-    rx530_cur."!mark_push"(0, rx530_pos, $I10)
-  rxscan533_done:
+    set rx506_pos, $P10
+    ge rx506_pos, rx506_eos, rxscan509_done
+  rxscan509_scan:
+    set_addr $I10, rxscan509_loop
+    rx506_cur."!mark_push"(0, rx506_pos, $I10)
+  rxscan509_done:
 .annotate 'line', 255
   # rx enumcharlist negate=0 
-    ge rx530_pos, rx530_eos, rx530_fail
-    sub $I10, rx530_pos, rx530_off
-    substr $S10, rx530_tgt, $I10, 1
+    ge rx506_pos, rx506_eos, rx506_fail
+    sub $I10, rx506_pos, rx506_off
+    substr $S10, rx506_tgt, $I10, 1
     index $I11, "$@%&", $S10
-    lt $I11, 0, rx530_fail
-    inc rx530_pos
+    lt $I11, 0, rx506_fail
+    inc rx506_pos
   # rx pass
-    rx530_cur."!cursor_pass"(rx530_pos, "sigil")
-    rx530_cur."!cursor_debug"("PASS  ", "sigil", " at pos=", rx530_pos)
-    .return (rx530_cur)
-  rx530_fail:
+    rx506_cur."!cursor_pass"(rx506_pos, "sigil")
+    rx506_cur."!cursor_debug"("PASS  ", "sigil", " at pos=", rx506_pos)
+    .return (rx506_cur)
+  rx506_restart:
 .annotate 'line', 4
-    (rx530_rep, rx530_pos, $I10, $P10) = rx530_cur."!mark_fail"(0)
-    lt rx530_pos, -1, rx530_done
-    eq rx530_pos, -1, rx530_fail
+    rx506_cur."!cursor_debug"("NEXT ", "sigil")
+  rx506_fail:
+    (rx506_rep, rx506_pos, $I10, $P10) = rx506_cur."!mark_fail"(0)
+    lt rx506_pos, -1, rx506_done
+    eq rx506_pos, -1, rx506_fail
     jump $I10
-  rx530_done:
-    rx530_cur."!cursor_fail"()
-    rx530_cur."!cursor_debug"("FAIL  ", "sigil")
-    .return (rx530_cur)
+  rx506_done:
+    rx506_cur."!cursor_fail"()
+    rx506_cur."!cursor_debug"("FAIL  ", "sigil")
+    .return (rx506_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__sigil"  :subid("127_1278500537.15927") :method
+.sub "!PREFIX__sigil"  :subid("127_1279529226.73787") :method
 .annotate 'line', 4
-    new $P532, "ResizablePMCArray"
-    push $P532, "&"
-    push $P532, "%"
-    push $P532, "@"
-    push $P532, "$"
-    .return ($P532)
+    new $P508, "ResizablePMCArray"
+    push $P508, "&"
+    push $P508, "%"
+    push $P508, "@"
+    push $P508, "$"
+    .return ($P508)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "twigil"  :subid("128_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx535_tgt
-    .local int rx535_pos
-    .local int rx535_off
-    .local int rx535_eos
-    .local int rx535_rep
-    .local pmc rx535_cur
-    (rx535_cur, rx535_pos, rx535_tgt) = self."!cursor_start"()
-    rx535_cur."!cursor_debug"("START ", "twigil")
-    .lex unicode:"$\x{a2}", rx535_cur
-    .local pmc match
-    .lex "$/", match
-    length rx535_eos, rx535_tgt
-    gt rx535_pos, rx535_eos, rx535_done
-    set rx535_off, 0
-    lt rx535_pos, 2, rx535_start
-    sub rx535_off, rx535_pos, 1
-    substr rx535_tgt, rx535_tgt, rx535_off
-  rx535_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan538_done
-    goto rxscan538_scan
-  rxscan538_loop:
-    ($P10) = rx535_cur."from"()
-    inc $P10
-    set rx535_pos, $P10
-    ge rx535_pos, rx535_eos, rxscan538_done
-  rxscan538_scan:
-    set_addr $I10, rxscan538_loop
-    rx535_cur."!mark_push"(0, rx535_pos, $I10)
-  rxscan538_done:
+.sub "twigil"  :subid("128_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx511_tgt
+    .local int rx511_pos
+    .local int rx511_off
+    .local int rx511_eos
+    .local int rx511_rep
+    .local pmc rx511_cur
+    (rx511_cur, rx511_pos, rx511_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx511_cur
+    .local pmc match
+    .lex "$/", match
+    length rx511_eos, rx511_tgt
+    gt rx511_pos, rx511_eos, rx511_done
+    set rx511_off, 0
+    lt rx511_pos, 2, rx511_start
+    sub rx511_off, rx511_pos, 1
+    substr rx511_tgt, rx511_tgt, rx511_off
+  rx511_start:
+    eq $I10, 1, rx511_restart
+    rx511_cur."!cursor_debug"("START ", "twigil")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan514_done
+    goto rxscan514_scan
+  rxscan514_loop:
+    ($P10) = rx511_cur."from"()
+    inc $P10
+    set rx511_pos, $P10
+    ge rx511_pos, rx511_eos, rxscan514_done
+  rxscan514_scan:
+    set_addr $I10, rxscan514_loop
+    rx511_cur."!mark_push"(0, rx511_pos, $I10)
+  rxscan514_done:
 .annotate 'line', 257
   # rx enumcharlist negate=0 
-    ge rx535_pos, rx535_eos, rx535_fail
-    sub $I10, rx535_pos, rx535_off
-    substr $S10, rx535_tgt, $I10, 1
+    ge rx511_pos, rx511_eos, rx511_fail
+    sub $I10, rx511_pos, rx511_off
+    substr $S10, rx511_tgt, $I10, 1
     index $I11, "*!?", $S10
-    lt $I11, 0, rx535_fail
-    inc rx535_pos
+    lt $I11, 0, rx511_fail
+    inc rx511_pos
   # rx pass
-    rx535_cur."!cursor_pass"(rx535_pos, "twigil")
-    rx535_cur."!cursor_debug"("PASS  ", "twigil", " at pos=", rx535_pos)
-    .return (rx535_cur)
-  rx535_fail:
+    rx511_cur."!cursor_pass"(rx511_pos, "twigil")
+    rx511_cur."!cursor_debug"("PASS  ", "twigil", " at pos=", rx511_pos)
+    .return (rx511_cur)
+  rx511_restart:
 .annotate 'line', 4
-    (rx535_rep, rx535_pos, $I10, $P10) = rx535_cur."!mark_fail"(0)
-    lt rx535_pos, -1, rx535_done
-    eq rx535_pos, -1, rx535_fail
+    rx511_cur."!cursor_debug"("NEXT ", "twigil")
+  rx511_fail:
+    (rx511_rep, rx511_pos, $I10, $P10) = rx511_cur."!mark_fail"(0)
+    lt rx511_pos, -1, rx511_done
+    eq rx511_pos, -1, rx511_fail
     jump $I10
-  rx535_done:
-    rx535_cur."!cursor_fail"()
-    rx535_cur."!cursor_debug"("FAIL  ", "twigil")
-    .return (rx535_cur)
+  rx511_done:
+    rx511_cur."!cursor_fail"()
+    rx511_cur."!cursor_debug"("FAIL  ", "twigil")
+    .return (rx511_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__twigil"  :subid("129_1278500537.15927") :method
+.sub "!PREFIX__twigil"  :subid("129_1279529226.73787") :method
 .annotate 'line', 4
-    new $P537, "ResizablePMCArray"
-    push $P537, "?"
-    push $P537, "!"
-    push $P537, "*"
-    .return ($P537)
+    new $P513, "ResizablePMCArray"
+    push $P513, "?"
+    push $P513, "!"
+    push $P513, "*"
+    .return ($P513)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "package_declarator"  :subid("130_1278500537.15927") :method
+.sub "package_declarator"  :subid("130_1279529226.73787") :method
 .annotate 'line', 259
-    $P540 = self."!protoregex"("package_declarator")
-    .return ($P540)
+    $P516 = self."!protoregex"("package_declarator")
+    .return ($P516)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__package_declarator"  :subid("131_1278500537.15927") :method
+.sub "!PREFIX__package_declarator"  :subid("131_1279529226.73787") :method
 .annotate 'line', 259
-    $P542 = self."!PREFIX__!protoregex"("package_declarator")
-    .return ($P542)
+    $P518 = self."!PREFIX__!protoregex"("package_declarator")
+    .return ($P518)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "package_declarator:sym<module>"  :subid("132_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "package_declarator:sym<module>"  :subid("132_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx544_tgt
-    .local int rx544_pos
-    .local int rx544_off
-    .local int rx544_eos
-    .local int rx544_rep
-    .local pmc rx544_cur
-    (rx544_cur, rx544_pos, rx544_tgt) = self."!cursor_start"()
-    rx544_cur."!cursor_debug"("START ", "package_declarator:sym<module>")
-    .lex unicode:"$\x{a2}", rx544_cur
-    .local pmc match
-    .lex "$/", match
-    length rx544_eos, rx544_tgt
-    gt rx544_pos, rx544_eos, rx544_done
-    set rx544_off, 0
-    lt rx544_pos, 2, rx544_start
-    sub rx544_off, rx544_pos, 1
-    substr rx544_tgt, rx544_tgt, rx544_off
-  rx544_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan548_done
-    goto rxscan548_scan
-  rxscan548_loop:
-    ($P10) = rx544_cur."from"()
-    inc $P10
-    set rx544_pos, $P10
-    ge rx544_pos, rx544_eos, rxscan548_done
-  rxscan548_scan:
-    set_addr $I10, rxscan548_loop
-    rx544_cur."!mark_push"(0, rx544_pos, $I10)
-  rxscan548_done:
+    .local string rx520_tgt
+    .local int rx520_pos
+    .local int rx520_off
+    .local int rx520_eos
+    .local int rx520_rep
+    .local pmc rx520_cur
+    (rx520_cur, rx520_pos, rx520_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx520_cur
+    .local pmc match
+    .lex "$/", match
+    length rx520_eos, rx520_tgt
+    gt rx520_pos, rx520_eos, rx520_done
+    set rx520_off, 0
+    lt rx520_pos, 2, rx520_start
+    sub rx520_off, rx520_pos, 1
+    substr rx520_tgt, rx520_tgt, rx520_off
+  rx520_start:
+    eq $I10, 1, rx520_restart
+    rx520_cur."!cursor_debug"("START ", "package_declarator:sym<module>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan524_done
+    goto rxscan524_scan
+  rxscan524_loop:
+    ($P10) = rx520_cur."from"()
+    inc $P10
+    set rx520_pos, $P10
+    ge rx520_pos, rx520_eos, rxscan524_done
+  rxscan524_scan:
+    set_addr $I10, rxscan524_loop
+    rx520_cur."!mark_push"(0, rx520_pos, $I10)
+  rxscan524_done:
 .annotate 'line', 260
   # rx subcapture "sym"
-    set_addr $I10, rxcap_549_fail
-    rx544_cur."!mark_push"(0, rx544_pos, $I10)
+    set_addr $I10, rxcap_525_fail
+    rx520_cur."!mark_push"(0, rx520_pos, $I10)
   # rx literal  "module"
-    add $I11, rx544_pos, 6
-    gt $I11, rx544_eos, rx544_fail
-    sub $I11, rx544_pos, rx544_off
-    substr $S10, rx544_tgt, $I11, 6
-    ne $S10, "module", rx544_fail
-    add rx544_pos, 6
-    set_addr $I10, rxcap_549_fail
-    ($I12, $I11) = rx544_cur."!mark_peek"($I10)
-    rx544_cur."!cursor_pos"($I11)
-    ($P10) = rx544_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx544_pos, "")
-    rx544_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx520_pos, 6
+    gt $I11, rx520_eos, rx520_fail
+    sub $I11, rx520_pos, rx520_off
+    substr $S10, rx520_tgt, $I11, 6
+    ne $S10, "module", rx520_fail
+    add rx520_pos, 6
+    set_addr $I10, rxcap_525_fail
+    ($I12, $I11) = rx520_cur."!mark_peek"($I10)
+    rx520_cur."!cursor_pos"($I11)
+    ($P10) = rx520_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx520_pos, "")
+    rx520_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_549_done
-  rxcap_549_fail:
-    goto rx544_fail
-  rxcap_549_done:
+    goto rxcap_525_done
+  rxcap_525_fail:
+    goto rx520_fail
+  rxcap_525_done:
   # rx subrule "package_def" subtype=capture negate=
-    rx544_cur."!cursor_pos"(rx544_pos)
-    $P10 = rx544_cur."package_def"()
-    unless $P10, rx544_fail
-    rx544_cur."!mark_push"(0, -1, 0, $P10)
+    rx520_cur."!cursor_pos"(rx520_pos)
+    $P10 = rx520_cur."package_def"()
+    unless $P10, rx520_fail
+    rx520_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("package_def")
-    rx544_pos = $P10."pos"()
+    rx520_pos = $P10."pos"()
   # rx pass
-    rx544_cur."!cursor_pass"(rx544_pos, "package_declarator:sym<module>")
-    rx544_cur."!cursor_debug"("PASS  ", "package_declarator:sym<module>", " at pos=", rx544_pos)
-    .return (rx544_cur)
-  rx544_fail:
+    rx520_cur."!cursor_pass"(rx520_pos, "package_declarator:sym<module>")
+    rx520_cur."!cursor_debug"("PASS  ", "package_declarator:sym<module>", " at pos=", rx520_pos)
+    .return (rx520_cur)
+  rx520_restart:
 .annotate 'line', 4
-    (rx544_rep, rx544_pos, $I10, $P10) = rx544_cur."!mark_fail"(0)
-    lt rx544_pos, -1, rx544_done
-    eq rx544_pos, -1, rx544_fail
+    rx520_cur."!cursor_debug"("NEXT ", "package_declarator:sym<module>")
+  rx520_fail:
+    (rx520_rep, rx520_pos, $I10, $P10) = rx520_cur."!mark_fail"(0)
+    lt rx520_pos, -1, rx520_done
+    eq rx520_pos, -1, rx520_fail
     jump $I10
-  rx544_done:
-    rx544_cur."!cursor_fail"()
-    rx544_cur."!cursor_debug"("FAIL  ", "package_declarator:sym<module>")
-    .return (rx544_cur)
+  rx520_done:
+    rx520_cur."!cursor_fail"()
+    rx520_cur."!cursor_debug"("FAIL  ", "package_declarator:sym<module>")
+    .return (rx520_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__package_declarator:sym<module>"  :subid("133_1278500537.15927") :method
+.sub "!PREFIX__package_declarator:sym<module>"  :subid("133_1279529226.73787") :method
 .annotate 'line', 4
-    $P546 = self."!PREFIX__!subrule"("package_def", "module")
-    new $P547, "ResizablePMCArray"
-    push $P547, $P546
-    .return ($P547)
+    $P522 = self."!PREFIX__!subrule"("package_def", "module")
+    new $P523, "ResizablePMCArray"
+    push $P523, $P522
+    .return ($P523)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "package_declarator:sym<class>"  :subid("134_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "package_declarator:sym<class>"  :subid("134_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx551_tgt
-    .local int rx551_pos
-    .local int rx551_off
-    .local int rx551_eos
-    .local int rx551_rep
-    .local pmc rx551_cur
-    (rx551_cur, rx551_pos, rx551_tgt) = self."!cursor_start"()
-    rx551_cur."!cursor_debug"("START ", "package_declarator:sym<class>")
-    .lex unicode:"$\x{a2}", rx551_cur
+    .local string rx527_tgt
+    .local int rx527_pos
+    .local int rx527_off
+    .local int rx527_eos
+    .local int rx527_rep
+    .local pmc rx527_cur
+    (rx527_cur, rx527_pos, rx527_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx527_cur
     .local pmc match
     .lex "$/", match
-    length rx551_eos, rx551_tgt
-    gt rx551_pos, rx551_eos, rx551_done
-    set rx551_off, 0
-    lt rx551_pos, 2, rx551_start
-    sub rx551_off, rx551_pos, 1
-    substr rx551_tgt, rx551_tgt, rx551_off
-  rx551_start:
+    length rx527_eos, rx527_tgt
+    gt rx527_pos, rx527_eos, rx527_done
+    set rx527_off, 0
+    lt rx527_pos, 2, rx527_start
+    sub rx527_off, rx527_pos, 1
+    substr rx527_tgt, rx527_tgt, rx527_off
+  rx527_start:
+    eq $I10, 1, rx527_restart
+    rx527_cur."!cursor_debug"("START ", "package_declarator:sym<class>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan556_done
-    goto rxscan556_scan
-  rxscan556_loop:
-    ($P10) = rx551_cur."from"()
+    ne $I10, -1, rxscan532_done
+    goto rxscan532_scan
+  rxscan532_loop:
+    ($P10) = rx527_cur."from"()
     inc $P10
-    set rx551_pos, $P10
-    ge rx551_pos, rx551_eos, rxscan556_done
-  rxscan556_scan:
-    set_addr $I10, rxscan556_loop
-    rx551_cur."!mark_push"(0, rx551_pos, $I10)
-  rxscan556_done:
+    set rx527_pos, $P10
+    ge rx527_pos, rx527_eos, rxscan532_done
+  rxscan532_scan:
+    set_addr $I10, rxscan532_loop
+    rx527_cur."!mark_push"(0, rx527_pos, $I10)
+  rxscan532_done:
 .annotate 'line', 261
   # rx subcapture "sym"
-    set_addr $I10, rxcap_558_fail
-    rx551_cur."!mark_push"(0, rx551_pos, $I10)
-  alt557_0:
-    set_addr $I10, alt557_1
-    rx551_cur."!mark_push"(0, rx551_pos, $I10)
+    set_addr $I10, rxcap_534_fail
+    rx527_cur."!mark_push"(0, rx527_pos, $I10)
+  alt533_0:
+    set_addr $I10, alt533_1
+    rx527_cur."!mark_push"(0, rx527_pos, $I10)
   # rx literal  "class"
-    add $I11, rx551_pos, 5
-    gt $I11, rx551_eos, rx551_fail
-    sub $I11, rx551_pos, rx551_off
-    substr $S10, rx551_tgt, $I11, 5
-    ne $S10, "class", rx551_fail
-    add rx551_pos, 5
-    goto alt557_end
-  alt557_1:
+    add $I11, rx527_pos, 5
+    gt $I11, rx527_eos, rx527_fail
+    sub $I11, rx527_pos, rx527_off
+    substr $S10, rx527_tgt, $I11, 5
+    ne $S10, "class", rx527_fail
+    add rx527_pos, 5
+    goto alt533_end
+  alt533_1:
   # rx literal  "grammar"
-    add $I11, rx551_pos, 7
-    gt $I11, rx551_eos, rx551_fail
-    sub $I11, rx551_pos, rx551_off
-    substr $S10, rx551_tgt, $I11, 7
-    ne $S10, "grammar", rx551_fail
-    add rx551_pos, 7
-  alt557_end:
-    set_addr $I10, rxcap_558_fail
-    ($I12, $I11) = rx551_cur."!mark_peek"($I10)
-    rx551_cur."!cursor_pos"($I11)
-    ($P10) = rx551_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx551_pos, "")
-    rx551_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx527_pos, 7
+    gt $I11, rx527_eos, rx527_fail
+    sub $I11, rx527_pos, rx527_off
+    substr $S10, rx527_tgt, $I11, 7
+    ne $S10, "grammar", rx527_fail
+    add rx527_pos, 7
+  alt533_end:
+    set_addr $I10, rxcap_534_fail
+    ($I12, $I11) = rx527_cur."!mark_peek"($I10)
+    rx527_cur."!cursor_pos"($I11)
+    ($P10) = rx527_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx527_pos, "")
+    rx527_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_558_done
-  rxcap_558_fail:
-    goto rx551_fail
-  rxcap_558_done:
+    goto rxcap_534_done
+  rxcap_534_fail:
+    goto rx527_fail
+  rxcap_534_done:
   # rx subrule "package_def" subtype=capture negate=
-    rx551_cur."!cursor_pos"(rx551_pos)
-    $P10 = rx551_cur."package_def"()
-    unless $P10, rx551_fail
-    rx551_cur."!mark_push"(0, -1, 0, $P10)
+    rx527_cur."!cursor_pos"(rx527_pos)
+    $P10 = rx527_cur."package_def"()
+    unless $P10, rx527_fail
+    rx527_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("package_def")
-    rx551_pos = $P10."pos"()
+    rx527_pos = $P10."pos"()
   # rx pass
-    rx551_cur."!cursor_pass"(rx551_pos, "package_declarator:sym<class>")
-    rx551_cur."!cursor_debug"("PASS  ", "package_declarator:sym<class>", " at pos=", rx551_pos)
-    .return (rx551_cur)
-  rx551_fail:
+    rx527_cur."!cursor_pass"(rx527_pos, "package_declarator:sym<class>")
+    rx527_cur."!cursor_debug"("PASS  ", "package_declarator:sym<class>", " at pos=", rx527_pos)
+    .return (rx527_cur)
+  rx527_restart:
 .annotate 'line', 4
-    (rx551_rep, rx551_pos, $I10, $P10) = rx551_cur."!mark_fail"(0)
-    lt rx551_pos, -1, rx551_done
-    eq rx551_pos, -1, rx551_fail
+    rx527_cur."!cursor_debug"("NEXT ", "package_declarator:sym<class>")
+  rx527_fail:
+    (rx527_rep, rx527_pos, $I10, $P10) = rx527_cur."!mark_fail"(0)
+    lt rx527_pos, -1, rx527_done
+    eq rx527_pos, -1, rx527_fail
     jump $I10
-  rx551_done:
-    rx551_cur."!cursor_fail"()
-    rx551_cur."!cursor_debug"("FAIL  ", "package_declarator:sym<class>")
-    .return (rx551_cur)
+  rx527_done:
+    rx527_cur."!cursor_fail"()
+    rx527_cur."!cursor_debug"("FAIL  ", "package_declarator:sym<class>")
+    .return (rx527_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__package_declarator:sym<class>"  :subid("135_1278500537.15927") :method
+.sub "!PREFIX__package_declarator:sym<class>"  :subid("135_1279529226.73787") :method
 .annotate 'line', 4
-    $P553 = self."!PREFIX__!subrule"("package_def", "grammar")
-    $P554 = self."!PREFIX__!subrule"("package_def", "class")
-    new $P555, "ResizablePMCArray"
-    push $P555, $P553
-    push $P555, $P554
-    .return ($P555)
+    $P529 = self."!PREFIX__!subrule"("package_def", "grammar")
+    $P530 = self."!PREFIX__!subrule"("package_def", "class")
+    new $P531, "ResizablePMCArray"
+    push $P531, $P529
+    push $P531, $P530
+    .return ($P531)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "package_def"  :subid("136_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "package_def"  :subid("136_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx560_tgt
-    .local int rx560_pos
-    .local int rx560_off
-    .local int rx560_eos
-    .local int rx560_rep
-    .local pmc rx560_cur
-    (rx560_cur, rx560_pos, rx560_tgt) = self."!cursor_start"()
-    rx560_cur."!cursor_debug"("START ", "package_def")
-    rx560_cur."!cursor_caparray"("parent")
-    .lex unicode:"$\x{a2}", rx560_cur
+    .local string rx536_tgt
+    .local int rx536_pos
+    .local int rx536_off
+    .local int rx536_eos
+    .local int rx536_rep
+    .local pmc rx536_cur
+    (rx536_cur, rx536_pos, rx536_tgt, $I10) = self."!cursor_start"()
+    rx536_cur."!cursor_caparray"("parent")
+    .lex unicode:"$\x{a2}", rx536_cur
     .local pmc match
     .lex "$/", match
-    length rx560_eos, rx560_tgt
-    gt rx560_pos, rx560_eos, rx560_done
-    set rx560_off, 0
-    lt rx560_pos, 2, rx560_start
-    sub rx560_off, rx560_pos, 1
-    substr rx560_tgt, rx560_tgt, rx560_off
-  rx560_start:
+    length rx536_eos, rx536_tgt
+    gt rx536_pos, rx536_eos, rx536_done
+    set rx536_off, 0
+    lt rx536_pos, 2, rx536_start
+    sub rx536_off, rx536_pos, 1
+    substr rx536_tgt, rx536_tgt, rx536_off
+  rx536_start:
+    eq $I10, 1, rx536_restart
+    rx536_cur."!cursor_debug"("START ", "package_def")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan564_done
-    goto rxscan564_scan
-  rxscan564_loop:
-    ($P10) = rx560_cur."from"()
+    ne $I10, -1, rxscan540_done
+    goto rxscan540_scan
+  rxscan540_loop:
+    ($P10) = rx536_cur."from"()
     inc $P10
-    set rx560_pos, $P10
-    ge rx560_pos, rx560_eos, rxscan564_done
-  rxscan564_scan:
-    set_addr $I10, rxscan564_loop
-    rx560_cur."!mark_push"(0, rx560_pos, $I10)
-  rxscan564_done:
+    set rx536_pos, $P10
+    ge rx536_pos, rx536_eos, rxscan540_done
+  rxscan540_scan:
+    set_addr $I10, rxscan540_loop
+    rx536_cur."!mark_push"(0, rx536_pos, $I10)
+  rxscan540_done:
 .annotate 'line', 263
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
 .annotate 'line', 264
   # rx subrule "name" subtype=capture negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."name"()
-    unless $P10, rx560_fail
-    rx560_cur."!mark_push"(0, -1, 0, $P10)
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."name"()
+    unless $P10, rx536_fail
+    rx536_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("name")
-    rx560_pos = $P10."pos"()
+    rx536_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
 .annotate 'line', 265
-  # rx rxquantr567 ** 0..1
-    set_addr $I571, rxquantr567_done
-    rx560_cur."!mark_push"(0, rx560_pos, $I571)
-  rxquantr567_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+  # rx rxquantr543 ** 0..1
+    set_addr $I10, rxquantr543_done
+    rx536_cur."!mark_push"(0, rx536_pos, $I10)
+  rxquantr543_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx literal  "is"
-    add $I11, rx560_pos, 2
-    gt $I11, rx560_eos, rx560_fail
-    sub $I11, rx560_pos, rx560_off
-    substr $S10, rx560_tgt, $I11, 2
-    ne $S10, "is", rx560_fail
-    add rx560_pos, 2
-  # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    add $I11, rx536_pos, 2
+    gt $I11, rx536_eos, rx536_fail
+    sub $I11, rx536_pos, rx536_off
+    substr $S10, rx536_tgt, $I11, 2
+    ne $S10, "is", rx536_fail
+    add rx536_pos, 2
+  # rx subrule "ws" subtype=method negate=
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx subrule "name" subtype=capture negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."name"()
-    unless $P10, rx560_fail
-    rx560_cur."!mark_push"(0, -1, 0, $P10)
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."name"()
+    unless $P10, rx536_fail
+    rx536_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("parent")
-    rx560_pos = $P10."pos"()
+    rx536_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
-    (rx560_rep) = rx560_cur."!mark_commit"($I571)
-  rxquantr567_done:
-  # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
-  alt573_0:
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
+    set_addr $I10, rxquantr543_done
+    (rx536_rep) = rx536_cur."!mark_commit"($I10)
+  rxquantr543_done:
+  # rx subrule "ws" subtype=method negate=
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
+  alt548_0:
 .annotate 'line', 266
-    set_addr $I10, alt573_1
-    rx560_cur."!mark_push"(0, rx560_pos, $I10)
+    set_addr $I10, alt548_1
+    rx536_cur."!mark_push"(0, rx536_pos, $I10)
 .annotate 'line', 267
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx literal  ";"
-    add $I11, rx560_pos, 1
-    gt $I11, rx560_eos, rx560_fail
-    sub $I11, rx560_pos, rx560_off
-    substr $S10, rx560_tgt, $I11, 1
-    ne $S10, ";", rx560_fail
-    add rx560_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    add $I11, rx536_pos, 1
+    gt $I11, rx536_eos, rx536_fail
+    sub $I11, rx536_pos, rx536_off
+    substr $S10, rx536_tgt, $I11, 1
+    ne $S10, ";", rx536_fail
+    add rx536_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx subrule "comp_unit" subtype=capture negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."comp_unit"()
-    unless $P10, rx560_fail
-    rx560_cur."!mark_push"(0, -1, 0, $P10)
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."comp_unit"()
+    unless $P10, rx536_fail
+    rx536_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("comp_unit")
-    rx560_pos = $P10."pos"()
+    rx536_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
-    goto alt573_end
-  alt573_1:
-    set_addr $I10, alt573_2
-    rx560_cur."!mark_push"(0, rx560_pos, $I10)
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
+    goto alt548_end
+  alt548_1:
+    set_addr $I10, alt548_2
+    rx536_cur."!mark_push"(0, rx536_pos, $I10)
 .annotate 'line', 268
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx enumcharlist negate=0 zerowidth
-    ge rx560_pos, rx560_eos, rx560_fail
-    sub $I10, rx560_pos, rx560_off
-    substr $S10, rx560_tgt, $I10, 1
+    ge rx536_pos, rx536_eos, rx536_fail
+    sub $I10, rx536_pos, rx536_off
+    substr $S10, rx536_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx560_fail
+    lt $I11, 0, rx536_fail
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx subrule "block" subtype=capture negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."block"()
-    unless $P10, rx560_fail
-    rx560_cur."!mark_push"(0, -1, 0, $P10)
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."block"()
+    unless $P10, rx536_fail
+    rx536_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("block")
-    rx560_pos = $P10."pos"()
+    rx536_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
-    goto alt573_end
-  alt573_2:
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
+    goto alt548_end
+  alt548_2:
 .annotate 'line', 269
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
   # rx subrule "panic" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."panic"("Malformed package declaration")
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
-  alt573_end:
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."panic"("Malformed package declaration")
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
+  alt548_end:
 .annotate 'line', 270
   # rx subrule "ws" subtype=method negate=
-    rx560_cur."!cursor_pos"(rx560_pos)
-    $P10 = rx560_cur."ws"()
-    unless $P10, rx560_fail
-    rx560_pos = $P10."pos"()
+    rx536_cur."!cursor_pos"(rx536_pos)
+    $P10 = rx536_cur."ws"()
+    unless $P10, rx536_fail
+    rx536_pos = $P10."pos"()
 .annotate 'line', 263
   # rx pass
-    rx560_cur."!cursor_pass"(rx560_pos, "package_def")
-    rx560_cur."!cursor_debug"("PASS  ", "package_def", " at pos=", rx560_pos)
-    .return (rx560_cur)
-  rx560_fail:
+    rx536_cur."!cursor_pass"(rx536_pos, "package_def")
+    rx536_cur."!cursor_debug"("PASS  ", "package_def", " at pos=", rx536_pos)
+    .return (rx536_cur)
+  rx536_restart:
 .annotate 'line', 4
-    (rx560_rep, rx560_pos, $I10, $P10) = rx560_cur."!mark_fail"(0)
-    lt rx560_pos, -1, rx560_done
-    eq rx560_pos, -1, rx560_fail
+    rx536_cur."!cursor_debug"("NEXT ", "package_def")
+  rx536_fail:
+    (rx536_rep, rx536_pos, $I10, $P10) = rx536_cur."!mark_fail"(0)
+    lt rx536_pos, -1, rx536_done
+    eq rx536_pos, -1, rx536_fail
     jump $I10
-  rx560_done:
-    rx560_cur."!cursor_fail"()
-    rx560_cur."!cursor_debug"("FAIL  ", "package_def")
-    .return (rx560_cur)
+  rx536_done:
+    rx536_cur."!cursor_fail"()
+    rx536_cur."!cursor_debug"("FAIL  ", "package_def")
+    .return (rx536_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__package_def"  :subid("137_1278500537.15927") :method
+.sub "!PREFIX__package_def"  :subid("137_1279529226.73787") :method
 .annotate 'line', 4
-    $P562 = self."!PREFIX__!subrule"("ws", "")
-    new $P563, "ResizablePMCArray"
-    push $P563, $P562
-    .return ($P563)
+    $P538 = self."!PREFIX__!subrule"("ws", "")
+    new $P539, "ResizablePMCArray"
+    push $P539, $P538
+    .return ($P539)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "scope_declarator"  :subid("138_1278500537.15927") :method
+.sub "scope_declarator"  :subid("138_1279529226.73787") :method
 .annotate 'line', 273
-    $P584 = self."!protoregex"("scope_declarator")
-    .return ($P584)
+    $P559 = self."!protoregex"("scope_declarator")
+    .return ($P559)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__scope_declarator"  :subid("139_1278500537.15927") :method
+.sub "!PREFIX__scope_declarator"  :subid("139_1279529226.73787") :method
 .annotate 'line', 273
-    $P586 = self."!PREFIX__!protoregex"("scope_declarator")
-    .return ($P586)
+    $P561 = self."!PREFIX__!protoregex"("scope_declarator")
+    .return ($P561)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "scope_declarator:sym<my>"  :subid("140_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "scope_declarator:sym<my>"  :subid("140_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx588_tgt
-    .local int rx588_pos
-    .local int rx588_off
-    .local int rx588_eos
-    .local int rx588_rep
-    .local pmc rx588_cur
-    (rx588_cur, rx588_pos, rx588_tgt) = self."!cursor_start"()
-    rx588_cur."!cursor_debug"("START ", "scope_declarator:sym<my>")
-    .lex unicode:"$\x{a2}", rx588_cur
-    .local pmc match
-    .lex "$/", match
-    length rx588_eos, rx588_tgt
-    gt rx588_pos, rx588_eos, rx588_done
-    set rx588_off, 0
-    lt rx588_pos, 2, rx588_start
-    sub rx588_off, rx588_pos, 1
-    substr rx588_tgt, rx588_tgt, rx588_off
-  rx588_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan592_done
-    goto rxscan592_scan
-  rxscan592_loop:
-    ($P10) = rx588_cur."from"()
-    inc $P10
-    set rx588_pos, $P10
-    ge rx588_pos, rx588_eos, rxscan592_done
-  rxscan592_scan:
-    set_addr $I10, rxscan592_loop
-    rx588_cur."!mark_push"(0, rx588_pos, $I10)
-  rxscan592_done:
+    .local string rx563_tgt
+    .local int rx563_pos
+    .local int rx563_off
+    .local int rx563_eos
+    .local int rx563_rep
+    .local pmc rx563_cur
+    (rx563_cur, rx563_pos, rx563_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx563_cur
+    .local pmc match
+    .lex "$/", match
+    length rx563_eos, rx563_tgt
+    gt rx563_pos, rx563_eos, rx563_done
+    set rx563_off, 0
+    lt rx563_pos, 2, rx563_start
+    sub rx563_off, rx563_pos, 1
+    substr rx563_tgt, rx563_tgt, rx563_off
+  rx563_start:
+    eq $I10, 1, rx563_restart
+    rx563_cur."!cursor_debug"("START ", "scope_declarator:sym<my>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan567_done
+    goto rxscan567_scan
+  rxscan567_loop:
+    ($P10) = rx563_cur."from"()
+    inc $P10
+    set rx563_pos, $P10
+    ge rx563_pos, rx563_eos, rxscan567_done
+  rxscan567_scan:
+    set_addr $I10, rxscan567_loop
+    rx563_cur."!mark_push"(0, rx563_pos, $I10)
+  rxscan567_done:
 .annotate 'line', 274
   # rx subcapture "sym"
-    set_addr $I10, rxcap_593_fail
-    rx588_cur."!mark_push"(0, rx588_pos, $I10)
+    set_addr $I10, rxcap_568_fail
+    rx563_cur."!mark_push"(0, rx563_pos, $I10)
   # rx literal  "my"
-    add $I11, rx588_pos, 2
-    gt $I11, rx588_eos, rx588_fail
-    sub $I11, rx588_pos, rx588_off
-    substr $S10, rx588_tgt, $I11, 2
-    ne $S10, "my", rx588_fail
-    add rx588_pos, 2
-    set_addr $I10, rxcap_593_fail
-    ($I12, $I11) = rx588_cur."!mark_peek"($I10)
-    rx588_cur."!cursor_pos"($I11)
-    ($P10) = rx588_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx588_pos, "")
-    rx588_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx563_pos, 2
+    gt $I11, rx563_eos, rx563_fail
+    sub $I11, rx563_pos, rx563_off
+    substr $S10, rx563_tgt, $I11, 2
+    ne $S10, "my", rx563_fail
+    add rx563_pos, 2
+    set_addr $I10, rxcap_568_fail
+    ($I12, $I11) = rx563_cur."!mark_peek"($I10)
+    rx563_cur."!cursor_pos"($I11)
+    ($P10) = rx563_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx563_pos, "")
+    rx563_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_593_done
-  rxcap_593_fail:
-    goto rx588_fail
-  rxcap_593_done:
+    goto rxcap_568_done
+  rxcap_568_fail:
+    goto rx563_fail
+  rxcap_568_done:
   # rx subrule "scoped" subtype=capture negate=
-    rx588_cur."!cursor_pos"(rx588_pos)
-    $P10 = rx588_cur."scoped"("my")
-    unless $P10, rx588_fail
-    rx588_cur."!mark_push"(0, -1, 0, $P10)
+    rx563_cur."!cursor_pos"(rx563_pos)
+    $P10 = rx563_cur."scoped"("my")
+    unless $P10, rx563_fail
+    rx563_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("scoped")
-    rx588_pos = $P10."pos"()
+    rx563_pos = $P10."pos"()
   # rx pass
-    rx588_cur."!cursor_pass"(rx588_pos, "scope_declarator:sym<my>")
-    rx588_cur."!cursor_debug"("PASS  ", "scope_declarator:sym<my>", " at pos=", rx588_pos)
-    .return (rx588_cur)
-  rx588_fail:
+    rx563_cur."!cursor_pass"(rx563_pos, "scope_declarator:sym<my>")
+    rx563_cur."!cursor_debug"("PASS  ", "scope_declarator:sym<my>", " at pos=", rx563_pos)
+    .return (rx563_cur)
+  rx563_restart:
 .annotate 'line', 4
-    (rx588_rep, rx588_pos, $I10, $P10) = rx588_cur."!mark_fail"(0)
-    lt rx588_pos, -1, rx588_done
-    eq rx588_pos, -1, rx588_fail
+    rx563_cur."!cursor_debug"("NEXT ", "scope_declarator:sym<my>")
+  rx563_fail:
+    (rx563_rep, rx563_pos, $I10, $P10) = rx563_cur."!mark_fail"(0)
+    lt rx563_pos, -1, rx563_done
+    eq rx563_pos, -1, rx563_fail
     jump $I10
-  rx588_done:
-    rx588_cur."!cursor_fail"()
-    rx588_cur."!cursor_debug"("FAIL  ", "scope_declarator:sym<my>")
-    .return (rx588_cur)
+  rx563_done:
+    rx563_cur."!cursor_fail"()
+    rx563_cur."!cursor_debug"("FAIL  ", "scope_declarator:sym<my>")
+    .return (rx563_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__scope_declarator:sym<my>"  :subid("141_1278500537.15927") :method
+.sub "!PREFIX__scope_declarator:sym<my>"  :subid("141_1279529226.73787") :method
 .annotate 'line', 4
-    $P590 = self."!PREFIX__!subrule"("scoped", "my")
-    new $P591, "ResizablePMCArray"
-    push $P591, $P590
-    .return ($P591)
+    $P565 = self."!PREFIX__!subrule"("scoped", "my")
+    new $P566, "ResizablePMCArray"
+    push $P566, $P565
+    .return ($P566)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "scope_declarator:sym<our>"  :subid("142_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "scope_declarator:sym<our>"  :subid("142_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx595_tgt
-    .local int rx595_pos
-    .local int rx595_off
-    .local int rx595_eos
-    .local int rx595_rep
-    .local pmc rx595_cur
-    (rx595_cur, rx595_pos, rx595_tgt) = self."!cursor_start"()
-    rx595_cur."!cursor_debug"("START ", "scope_declarator:sym<our>")
-    .lex unicode:"$\x{a2}", rx595_cur
+    .local string rx570_tgt
+    .local int rx570_pos
+    .local int rx570_off
+    .local int rx570_eos
+    .local int rx570_rep
+    .local pmc rx570_cur
+    (rx570_cur, rx570_pos, rx570_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx570_cur
     .local pmc match
     .lex "$/", match
-    length rx595_eos, rx595_tgt
-    gt rx595_pos, rx595_eos, rx595_done
-    set rx595_off, 0
-    lt rx595_pos, 2, rx595_start
-    sub rx595_off, rx595_pos, 1
-    substr rx595_tgt, rx595_tgt, rx595_off
-  rx595_start:
+    length rx570_eos, rx570_tgt
+    gt rx570_pos, rx570_eos, rx570_done
+    set rx570_off, 0
+    lt rx570_pos, 2, rx570_start
+    sub rx570_off, rx570_pos, 1
+    substr rx570_tgt, rx570_tgt, rx570_off
+  rx570_start:
+    eq $I10, 1, rx570_restart
+    rx570_cur."!cursor_debug"("START ", "scope_declarator:sym<our>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan599_done
-    goto rxscan599_scan
-  rxscan599_loop:
-    ($P10) = rx595_cur."from"()
+    ne $I10, -1, rxscan574_done
+    goto rxscan574_scan
+  rxscan574_loop:
+    ($P10) = rx570_cur."from"()
     inc $P10
-    set rx595_pos, $P10
-    ge rx595_pos, rx595_eos, rxscan599_done
-  rxscan599_scan:
-    set_addr $I10, rxscan599_loop
-    rx595_cur."!mark_push"(0, rx595_pos, $I10)
-  rxscan599_done:
+    set rx570_pos, $P10
+    ge rx570_pos, rx570_eos, rxscan574_done
+  rxscan574_scan:
+    set_addr $I10, rxscan574_loop
+    rx570_cur."!mark_push"(0, rx570_pos, $I10)
+  rxscan574_done:
 .annotate 'line', 275
   # rx subcapture "sym"
-    set_addr $I10, rxcap_600_fail
-    rx595_cur."!mark_push"(0, rx595_pos, $I10)
+    set_addr $I10, rxcap_575_fail
+    rx570_cur."!mark_push"(0, rx570_pos, $I10)
   # rx literal  "our"
-    add $I11, rx595_pos, 3
-    gt $I11, rx595_eos, rx595_fail
-    sub $I11, rx595_pos, rx595_off
-    substr $S10, rx595_tgt, $I11, 3
-    ne $S10, "our", rx595_fail
-    add rx595_pos, 3
-    set_addr $I10, rxcap_600_fail
-    ($I12, $I11) = rx595_cur."!mark_peek"($I10)
-    rx595_cur."!cursor_pos"($I11)
-    ($P10) = rx595_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx595_pos, "")
-    rx595_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx570_pos, 3
+    gt $I11, rx570_eos, rx570_fail
+    sub $I11, rx570_pos, rx570_off
+    substr $S10, rx570_tgt, $I11, 3
+    ne $S10, "our", rx570_fail
+    add rx570_pos, 3
+    set_addr $I10, rxcap_575_fail
+    ($I12, $I11) = rx570_cur."!mark_peek"($I10)
+    rx570_cur."!cursor_pos"($I11)
+    ($P10) = rx570_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx570_pos, "")
+    rx570_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_600_done
-  rxcap_600_fail:
-    goto rx595_fail
-  rxcap_600_done:
+    goto rxcap_575_done
+  rxcap_575_fail:
+    goto rx570_fail
+  rxcap_575_done:
   # rx subrule "scoped" subtype=capture negate=
-    rx595_cur."!cursor_pos"(rx595_pos)
-    $P10 = rx595_cur."scoped"("our")
-    unless $P10, rx595_fail
-    rx595_cur."!mark_push"(0, -1, 0, $P10)
+    rx570_cur."!cursor_pos"(rx570_pos)
+    $P10 = rx570_cur."scoped"("our")
+    unless $P10, rx570_fail
+    rx570_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("scoped")
-    rx595_pos = $P10."pos"()
+    rx570_pos = $P10."pos"()
   # rx pass
-    rx595_cur."!cursor_pass"(rx595_pos, "scope_declarator:sym<our>")
-    rx595_cur."!cursor_debug"("PASS  ", "scope_declarator:sym<our>", " at pos=", rx595_pos)
-    .return (rx595_cur)
-  rx595_fail:
+    rx570_cur."!cursor_pass"(rx570_pos, "scope_declarator:sym<our>")
+    rx570_cur."!cursor_debug"("PASS  ", "scope_declarator:sym<our>", " at pos=", rx570_pos)
+    .return (rx570_cur)
+  rx570_restart:
 .annotate 'line', 4
-    (rx595_rep, rx595_pos, $I10, $P10) = rx595_cur."!mark_fail"(0)
-    lt rx595_pos, -1, rx595_done
-    eq rx595_pos, -1, rx595_fail
+    rx570_cur."!cursor_debug"("NEXT ", "scope_declarator:sym<our>")
+  rx570_fail:
+    (rx570_rep, rx570_pos, $I10, $P10) = rx570_cur."!mark_fail"(0)
+    lt rx570_pos, -1, rx570_done
+    eq rx570_pos, -1, rx570_fail
     jump $I10
-  rx595_done:
-    rx595_cur."!cursor_fail"()
-    rx595_cur."!cursor_debug"("FAIL  ", "scope_declarator:sym<our>")
-    .return (rx595_cur)
+  rx570_done:
+    rx570_cur."!cursor_fail"()
+    rx570_cur."!cursor_debug"("FAIL  ", "scope_declarator:sym<our>")
+    .return (rx570_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__scope_declarator:sym<our>"  :subid("143_1278500537.15927") :method
+.sub "!PREFIX__scope_declarator:sym<our>"  :subid("143_1279529226.73787") :method
 .annotate 'line', 4
-    $P597 = self."!PREFIX__!subrule"("scoped", "our")
-    new $P598, "ResizablePMCArray"
-    push $P598, $P597
-    .return ($P598)
+    $P572 = self."!PREFIX__!subrule"("scoped", "our")
+    new $P573, "ResizablePMCArray"
+    push $P573, $P572
+    .return ($P573)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "scope_declarator:sym<has>"  :subid("144_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "scope_declarator:sym<has>"  :subid("144_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx602_tgt
-    .local int rx602_pos
-    .local int rx602_off
-    .local int rx602_eos
-    .local int rx602_rep
-    .local pmc rx602_cur
-    (rx602_cur, rx602_pos, rx602_tgt) = self."!cursor_start"()
-    rx602_cur."!cursor_debug"("START ", "scope_declarator:sym<has>")
-    .lex unicode:"$\x{a2}", rx602_cur
+    .local string rx577_tgt
+    .local int rx577_pos
+    .local int rx577_off
+    .local int rx577_eos
+    .local int rx577_rep
+    .local pmc rx577_cur
+    (rx577_cur, rx577_pos, rx577_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx577_cur
     .local pmc match
     .lex "$/", match
-    length rx602_eos, rx602_tgt
-    gt rx602_pos, rx602_eos, rx602_done
-    set rx602_off, 0
-    lt rx602_pos, 2, rx602_start
-    sub rx602_off, rx602_pos, 1
-    substr rx602_tgt, rx602_tgt, rx602_off
-  rx602_start:
+    length rx577_eos, rx577_tgt
+    gt rx577_pos, rx577_eos, rx577_done
+    set rx577_off, 0
+    lt rx577_pos, 2, rx577_start
+    sub rx577_off, rx577_pos, 1
+    substr rx577_tgt, rx577_tgt, rx577_off
+  rx577_start:
+    eq $I10, 1, rx577_restart
+    rx577_cur."!cursor_debug"("START ", "scope_declarator:sym<has>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan606_done
-    goto rxscan606_scan
-  rxscan606_loop:
-    ($P10) = rx602_cur."from"()
+    ne $I10, -1, rxscan581_done
+    goto rxscan581_scan
+  rxscan581_loop:
+    ($P10) = rx577_cur."from"()
     inc $P10
-    set rx602_pos, $P10
-    ge rx602_pos, rx602_eos, rxscan606_done
-  rxscan606_scan:
-    set_addr $I10, rxscan606_loop
-    rx602_cur."!mark_push"(0, rx602_pos, $I10)
-  rxscan606_done:
+    set rx577_pos, $P10
+    ge rx577_pos, rx577_eos, rxscan581_done
+  rxscan581_scan:
+    set_addr $I10, rxscan581_loop
+    rx577_cur."!mark_push"(0, rx577_pos, $I10)
+  rxscan581_done:
 .annotate 'line', 276
   # rx subcapture "sym"
-    set_addr $I10, rxcap_607_fail
-    rx602_cur."!mark_push"(0, rx602_pos, $I10)
+    set_addr $I10, rxcap_582_fail
+    rx577_cur."!mark_push"(0, rx577_pos, $I10)
   # rx literal  "has"
-    add $I11, rx602_pos, 3
-    gt $I11, rx602_eos, rx602_fail
-    sub $I11, rx602_pos, rx602_off
-    substr $S10, rx602_tgt, $I11, 3
-    ne $S10, "has", rx602_fail
-    add rx602_pos, 3
-    set_addr $I10, rxcap_607_fail
-    ($I12, $I11) = rx602_cur."!mark_peek"($I10)
-    rx602_cur."!cursor_pos"($I11)
-    ($P10) = rx602_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx602_pos, "")
-    rx602_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx577_pos, 3
+    gt $I11, rx577_eos, rx577_fail
+    sub $I11, rx577_pos, rx577_off
+    substr $S10, rx577_tgt, $I11, 3
+    ne $S10, "has", rx577_fail
+    add rx577_pos, 3
+    set_addr $I10, rxcap_582_fail
+    ($I12, $I11) = rx577_cur."!mark_peek"($I10)
+    rx577_cur."!cursor_pos"($I11)
+    ($P10) = rx577_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx577_pos, "")
+    rx577_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_607_done
-  rxcap_607_fail:
-    goto rx602_fail
-  rxcap_607_done:
+    goto rxcap_582_done
+  rxcap_582_fail:
+    goto rx577_fail
+  rxcap_582_done:
   # rx subrule "scoped" subtype=capture negate=
-    rx602_cur."!cursor_pos"(rx602_pos)
-    $P10 = rx602_cur."scoped"("has")
-    unless $P10, rx602_fail
-    rx602_cur."!mark_push"(0, -1, 0, $P10)
+    rx577_cur."!cursor_pos"(rx577_pos)
+    $P10 = rx577_cur."scoped"("has")
+    unless $P10, rx577_fail
+    rx577_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("scoped")
-    rx602_pos = $P10."pos"()
+    rx577_pos = $P10."pos"()
   # rx pass
-    rx602_cur."!cursor_pass"(rx602_pos, "scope_declarator:sym<has>")
-    rx602_cur."!cursor_debug"("PASS  ", "scope_declarator:sym<has>", " at pos=", rx602_pos)
-    .return (rx602_cur)
-  rx602_fail:
+    rx577_cur."!cursor_pass"(rx577_pos, "scope_declarator:sym<has>")
+    rx577_cur."!cursor_debug"("PASS  ", "scope_declarator:sym<has>", " at pos=", rx577_pos)
+    .return (rx577_cur)
+  rx577_restart:
 .annotate 'line', 4
-    (rx602_rep, rx602_pos, $I10, $P10) = rx602_cur."!mark_fail"(0)
-    lt rx602_pos, -1, rx602_done
-    eq rx602_pos, -1, rx602_fail
+    rx577_cur."!cursor_debug"("NEXT ", "scope_declarator:sym<has>")
+  rx577_fail:
+    (rx577_rep, rx577_pos, $I10, $P10) = rx577_cur."!mark_fail"(0)
+    lt rx577_pos, -1, rx577_done
+    eq rx577_pos, -1, rx577_fail
     jump $I10
-  rx602_done:
-    rx602_cur."!cursor_fail"()
-    rx602_cur."!cursor_debug"("FAIL  ", "scope_declarator:sym<has>")
-    .return (rx602_cur)
+  rx577_done:
+    rx577_cur."!cursor_fail"()
+    rx577_cur."!cursor_debug"("FAIL  ", "scope_declarator:sym<has>")
+    .return (rx577_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__scope_declarator:sym<has>"  :subid("145_1278500537.15927") :method
+.sub "!PREFIX__scope_declarator:sym<has>"  :subid("145_1279529226.73787") :method
 .annotate 'line', 4
-    $P604 = self."!PREFIX__!subrule"("scoped", "has")
-    new $P605, "ResizablePMCArray"
-    push $P605, $P604
-    .return ($P605)
+    $P579 = self."!PREFIX__!subrule"("scoped", "has")
+    new $P580, "ResizablePMCArray"
+    push $P580, $P579
+    .return ($P580)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "scoped"  :subid("146_1278500537.15927") :method :outer("11_1278500537.15927")
-    .param pmc param_609
+.sub "scoped"  :subid("146_1279529226.73787") :method :outer("11_1279529226.73787")
+    .param pmc param_584
 .annotate 'line', 278
-    .lex "$*SCOPE", param_609
+    .lex "$*SCOPE", param_584
 .annotate 'line', 4
-    .local string rx610_tgt
-    .local int rx610_pos
-    .local int rx610_off
-    .local int rx610_eos
-    .local int rx610_rep
-    .local pmc rx610_cur
-    (rx610_cur, rx610_pos, rx610_tgt) = self."!cursor_start"()
-    rx610_cur."!cursor_debug"("START ", "scoped")
-    .lex unicode:"$\x{a2}", rx610_cur
-    .local pmc match
-    .lex "$/", match
-    length rx610_eos, rx610_tgt
-    gt rx610_pos, rx610_eos, rx610_done
-    set rx610_off, 0
-    lt rx610_pos, 2, rx610_start
-    sub rx610_off, rx610_pos, 1
-    substr rx610_tgt, rx610_tgt, rx610_off
-  rx610_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan615_done
-    goto rxscan615_scan
-  rxscan615_loop:
-    ($P10) = rx610_cur."from"()
-    inc $P10
-    set rx610_pos, $P10
-    ge rx610_pos, rx610_eos, rxscan615_done
-  rxscan615_scan:
-    set_addr $I10, rxscan615_loop
-    rx610_cur."!mark_push"(0, rx610_pos, $I10)
-  rxscan615_done:
-  alt616_0:
+    .local string rx585_tgt
+    .local int rx585_pos
+    .local int rx585_off
+    .local int rx585_eos
+    .local int rx585_rep
+    .local pmc rx585_cur
+    (rx585_cur, rx585_pos, rx585_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx585_cur
+    .local pmc match
+    .lex "$/", match
+    length rx585_eos, rx585_tgt
+    gt rx585_pos, rx585_eos, rx585_done
+    set rx585_off, 0
+    lt rx585_pos, 2, rx585_start
+    sub rx585_off, rx585_pos, 1
+    substr rx585_tgt, rx585_tgt, rx585_off
+  rx585_start:
+    eq $I10, 1, rx585_restart
+    rx585_cur."!cursor_debug"("START ", "scoped")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan590_done
+    goto rxscan590_scan
+  rxscan590_loop:
+    ($P10) = rx585_cur."from"()
+    inc $P10
+    set rx585_pos, $P10
+    ge rx585_pos, rx585_eos, rxscan590_done
+  rxscan590_scan:
+    set_addr $I10, rxscan590_loop
+    rx585_cur."!mark_push"(0, rx585_pos, $I10)
+  rxscan590_done:
+  alt591_0:
 .annotate 'line', 278
-    set_addr $I10, alt616_1
-    rx610_cur."!mark_push"(0, rx610_pos, $I10)
+    set_addr $I10, alt591_1
+    rx585_cur."!mark_push"(0, rx585_pos, $I10)
 .annotate 'line', 279
   # rx subrule "ws" subtype=method negate=
-    rx610_cur."!cursor_pos"(rx610_pos)
-    $P10 = rx610_cur."ws"()
-    unless $P10, rx610_fail
-    rx610_pos = $P10."pos"()
+    rx585_cur."!cursor_pos"(rx585_pos)
+    $P10 = rx585_cur."ws"()
+    unless $P10, rx585_fail
+    rx585_pos = $P10."pos"()
   # rx subrule "declarator" subtype=capture negate=
-    rx610_cur."!cursor_pos"(rx610_pos)
-    $P10 = rx610_cur."declarator"()
-    unless $P10, rx610_fail
-    rx610_cur."!mark_push"(0, -1, 0, $P10)
+    rx585_cur."!cursor_pos"(rx585_pos)
+    $P10 = rx585_cur."declarator"()
+    unless $P10, rx585_fail
+    rx585_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("declarator")
-    rx610_pos = $P10."pos"()
+    rx585_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx610_cur."!cursor_pos"(rx610_pos)
-    $P10 = rx610_cur."ws"()
-    unless $P10, rx610_fail
-    rx610_pos = $P10."pos"()
-    goto alt616_end
-  alt616_1:
+    rx585_cur."!cursor_pos"(rx585_pos)
+    $P10 = rx585_cur."ws"()
+    unless $P10, rx585_fail
+    rx585_pos = $P10."pos"()
+    goto alt591_end
+  alt591_1:
 .annotate 'line', 280
   # rx subrule "ws" subtype=method negate=
-    rx610_cur."!cursor_pos"(rx610_pos)
-    $P10 = rx610_cur."ws"()
-    unless $P10, rx610_fail
-    rx610_pos = $P10."pos"()
+    rx585_cur."!cursor_pos"(rx585_pos)
+    $P10 = rx585_cur."ws"()
+    unless $P10, rx585_fail
+    rx585_pos = $P10."pos"()
   # rx subrule "multi_declarator" subtype=capture negate=
-    rx610_cur."!cursor_pos"(rx610_pos)
-    $P10 = rx610_cur."multi_declarator"()
-    unless $P10, rx610_fail
-    rx610_cur."!mark_push"(0, -1, 0, $P10)
+    rx585_cur."!cursor_pos"(rx585_pos)
+    $P10 = rx585_cur."multi_declarator"()
+    unless $P10, rx585_fail
+    rx585_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("multi_declarator")
-    rx610_pos = $P10."pos"()
+    rx585_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx610_cur."!cursor_pos"(rx610_pos)
-    $P10 = rx610_cur."ws"()
-    unless $P10, rx610_fail
-    rx610_pos = $P10."pos"()
-  alt616_end:
+    rx585_cur."!cursor_pos"(rx585_pos)
+    $P10 = rx585_cur."ws"()
+    unless $P10, rx585_fail
+    rx585_pos = $P10."pos"()
+  alt591_end:
 .annotate 'line', 278
   # rx pass
-    rx610_cur."!cursor_pass"(rx610_pos, "scoped")
-    rx610_cur."!cursor_debug"("PASS  ", "scoped", " at pos=", rx610_pos)
-    .return (rx610_cur)
-  rx610_fail:
+    rx585_cur."!cursor_pass"(rx585_pos, "scoped")
+    rx585_cur."!cursor_debug"("PASS  ", "scoped", " at pos=", rx585_pos)
+    .return (rx585_cur)
+  rx585_restart:
 .annotate 'line', 4
-    (rx610_rep, rx610_pos, $I10, $P10) = rx610_cur."!mark_fail"(0)
-    lt rx610_pos, -1, rx610_done
-    eq rx610_pos, -1, rx610_fail
+    rx585_cur."!cursor_debug"("NEXT ", "scoped")
+  rx585_fail:
+    (rx585_rep, rx585_pos, $I10, $P10) = rx585_cur."!mark_fail"(0)
+    lt rx585_pos, -1, rx585_done
+    eq rx585_pos, -1, rx585_fail
     jump $I10
-  rx610_done:
-    rx610_cur."!cursor_fail"()
-    rx610_cur."!cursor_debug"("FAIL  ", "scoped")
-    .return (rx610_cur)
+  rx585_done:
+    rx585_cur."!cursor_fail"()
+    rx585_cur."!cursor_debug"("FAIL  ", "scoped")
+    .return (rx585_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__scoped"  :subid("147_1278500537.15927") :method
+.sub "!PREFIX__scoped"  :subid("147_1279529226.73787") :method
 .annotate 'line', 4
-    $P612 = self."!PREFIX__!subrule"("ws", "")
-    $P613 = self."!PREFIX__!subrule"("ws", "")
-    new $P614, "ResizablePMCArray"
-    push $P614, $P612
-    push $P614, $P613
-    .return ($P614)
+    $P587 = self."!PREFIX__!subrule"("ws", "")
+    $P588 = self."!PREFIX__!subrule"("ws", "")
+    new $P589, "ResizablePMCArray"
+    push $P589, $P587
+    push $P589, $P588
+    .return ($P589)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "typename"  :subid("148_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "typename"  :subid("148_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx622_tgt
-    .local int rx622_pos
-    .local int rx622_off
-    .local int rx622_eos
-    .local int rx622_rep
-    .local pmc rx622_cur
-    (rx622_cur, rx622_pos, rx622_tgt) = self."!cursor_start"()
-    rx622_cur."!cursor_debug"("START ", "typename")
-    .lex unicode:"$\x{a2}", rx622_cur
-    .local pmc match
-    .lex "$/", match
-    length rx622_eos, rx622_tgt
-    gt rx622_pos, rx622_eos, rx622_done
-    set rx622_off, 0
-    lt rx622_pos, 2, rx622_start
-    sub rx622_off, rx622_pos, 1
-    substr rx622_tgt, rx622_tgt, rx622_off
-  rx622_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan626_done
-    goto rxscan626_scan
-  rxscan626_loop:
-    ($P10) = rx622_cur."from"()
-    inc $P10
-    set rx622_pos, $P10
-    ge rx622_pos, rx622_eos, rxscan626_done
-  rxscan626_scan:
-    set_addr $I10, rxscan626_loop
-    rx622_cur."!mark_push"(0, rx622_pos, $I10)
-  rxscan626_done:
+    .local string rx597_tgt
+    .local int rx597_pos
+    .local int rx597_off
+    .local int rx597_eos
+    .local int rx597_rep
+    .local pmc rx597_cur
+    (rx597_cur, rx597_pos, rx597_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx597_cur
+    .local pmc match
+    .lex "$/", match
+    length rx597_eos, rx597_tgt
+    gt rx597_pos, rx597_eos, rx597_done
+    set rx597_off, 0
+    lt rx597_pos, 2, rx597_start
+    sub rx597_off, rx597_pos, 1
+    substr rx597_tgt, rx597_tgt, rx597_off
+  rx597_start:
+    eq $I10, 1, rx597_restart
+    rx597_cur."!cursor_debug"("START ", "typename")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan601_done
+    goto rxscan601_scan
+  rxscan601_loop:
+    ($P10) = rx597_cur."from"()
+    inc $P10
+    set rx597_pos, $P10
+    ge rx597_pos, rx597_eos, rxscan601_done
+  rxscan601_scan:
+    set_addr $I10, rxscan601_loop
+    rx597_cur."!mark_push"(0, rx597_pos, $I10)
+  rxscan601_done:
 .annotate 'line', 283
   # rx subrule "name" subtype=capture negate=
-    rx622_cur."!cursor_pos"(rx622_pos)
-    $P10 = rx622_cur."name"()
-    unless $P10, rx622_fail
-    rx622_cur."!mark_push"(0, -1, 0, $P10)
+    rx597_cur."!cursor_pos"(rx597_pos)
+    $P10 = rx597_cur."name"()
+    unless $P10, rx597_fail
+    rx597_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("name")
-    rx622_pos = $P10."pos"()
+    rx597_pos = $P10."pos"()
   # rx pass
-    rx622_cur."!cursor_pass"(rx622_pos, "typename")
-    rx622_cur."!cursor_debug"("PASS  ", "typename", " at pos=", rx622_pos)
-    .return (rx622_cur)
-  rx622_fail:
+    rx597_cur."!cursor_pass"(rx597_pos, "typename")
+    rx597_cur."!cursor_debug"("PASS  ", "typename", " at pos=", rx597_pos)
+    .return (rx597_cur)
+  rx597_restart:
 .annotate 'line', 4
-    (rx622_rep, rx622_pos, $I10, $P10) = rx622_cur."!mark_fail"(0)
-    lt rx622_pos, -1, rx622_done
-    eq rx622_pos, -1, rx622_fail
+    rx597_cur."!cursor_debug"("NEXT ", "typename")
+  rx597_fail:
+    (rx597_rep, rx597_pos, $I10, $P10) = rx597_cur."!mark_fail"(0)
+    lt rx597_pos, -1, rx597_done
+    eq rx597_pos, -1, rx597_fail
     jump $I10
-  rx622_done:
-    rx622_cur."!cursor_fail"()
-    rx622_cur."!cursor_debug"("FAIL  ", "typename")
-    .return (rx622_cur)
+  rx597_done:
+    rx597_cur."!cursor_fail"()
+    rx597_cur."!cursor_debug"("FAIL  ", "typename")
+    .return (rx597_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__typename"  :subid("149_1278500537.15927") :method
+.sub "!PREFIX__typename"  :subid("149_1279529226.73787") :method
 .annotate 'line', 4
-    $P624 = self."!PREFIX__!subrule"("name", "")
-    new $P625, "ResizablePMCArray"
-    push $P625, $P624
-    .return ($P625)
+    $P599 = self."!PREFIX__!subrule"("name", "")
+    new $P600, "ResizablePMCArray"
+    push $P600, $P599
+    .return ($P600)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "declarator"  :subid("150_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "declarator"  :subid("150_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx628_tgt
-    .local int rx628_pos
-    .local int rx628_off
-    .local int rx628_eos
-    .local int rx628_rep
-    .local pmc rx628_cur
-    (rx628_cur, rx628_pos, rx628_tgt) = self."!cursor_start"()
-    rx628_cur."!cursor_debug"("START ", "declarator")
-    .lex unicode:"$\x{a2}", rx628_cur
+    .local string rx603_tgt
+    .local int rx603_pos
+    .local int rx603_off
+    .local int rx603_eos
+    .local int rx603_rep
+    .local pmc rx603_cur
+    (rx603_cur, rx603_pos, rx603_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx603_cur
     .local pmc match
     .lex "$/", match
-    length rx628_eos, rx628_tgt
-    gt rx628_pos, rx628_eos, rx628_done
-    set rx628_off, 0
-    lt rx628_pos, 2, rx628_start
-    sub rx628_off, rx628_pos, 1
-    substr rx628_tgt, rx628_tgt, rx628_off
-  rx628_start:
+    length rx603_eos, rx603_tgt
+    gt rx603_pos, rx603_eos, rx603_done
+    set rx603_off, 0
+    lt rx603_pos, 2, rx603_start
+    sub rx603_off, rx603_pos, 1
+    substr rx603_tgt, rx603_tgt, rx603_off
+  rx603_start:
+    eq $I10, 1, rx603_restart
+    rx603_cur."!cursor_debug"("START ", "declarator")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan633_done
-    goto rxscan633_scan
-  rxscan633_loop:
-    ($P10) = rx628_cur."from"()
+    ne $I10, -1, rxscan608_done
+    goto rxscan608_scan
+  rxscan608_loop:
+    ($P10) = rx603_cur."from"()
     inc $P10
-    set rx628_pos, $P10
-    ge rx628_pos, rx628_eos, rxscan633_done
-  rxscan633_scan:
-    set_addr $I10, rxscan633_loop
-    rx628_cur."!mark_push"(0, rx628_pos, $I10)
-  rxscan633_done:
-  alt634_0:
+    set rx603_pos, $P10
+    ge rx603_pos, rx603_eos, rxscan608_done
+  rxscan608_scan:
+    set_addr $I10, rxscan608_loop
+    rx603_cur."!mark_push"(0, rx603_pos, $I10)
+  rxscan608_done:
+  alt609_0:
 .annotate 'line', 285
-    set_addr $I10, alt634_1
-    rx628_cur."!mark_push"(0, rx628_pos, $I10)
+    set_addr $I10, alt609_1
+    rx603_cur."!mark_push"(0, rx603_pos, $I10)
 .annotate 'line', 286
   # rx subrule "variable_declarator" subtype=capture negate=
-    rx628_cur."!cursor_pos"(rx628_pos)
-    $P10 = rx628_cur."variable_declarator"()
-    unless $P10, rx628_fail
-    rx628_cur."!mark_push"(0, -1, 0, $P10)
+    rx603_cur."!cursor_pos"(rx603_pos)
+    $P10 = rx603_cur."variable_declarator"()
+    unless $P10, rx603_fail
+    rx603_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("variable_declarator")
-    rx628_pos = $P10."pos"()
-    goto alt634_end
-  alt634_1:
+    rx603_pos = $P10."pos"()
+    goto alt609_end
+  alt609_1:
 .annotate 'line', 287
   # rx subrule "routine_declarator" subtype=capture negate=
-    rx628_cur."!cursor_pos"(rx628_pos)
-    $P10 = rx628_cur."routine_declarator"()
-    unless $P10, rx628_fail
-    rx628_cur."!mark_push"(0, -1, 0, $P10)
+    rx603_cur."!cursor_pos"(rx603_pos)
+    $P10 = rx603_cur."routine_declarator"()
+    unless $P10, rx603_fail
+    rx603_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("routine_declarator")
-    rx628_pos = $P10."pos"()
-  alt634_end:
+    rx603_pos = $P10."pos"()
+  alt609_end:
 .annotate 'line', 285
   # rx pass
-    rx628_cur."!cursor_pass"(rx628_pos, "declarator")
-    rx628_cur."!cursor_debug"("PASS  ", "declarator", " at pos=", rx628_pos)
-    .return (rx628_cur)
-  rx628_fail:
+    rx603_cur."!cursor_pass"(rx603_pos, "declarator")
+    rx603_cur."!cursor_debug"("PASS  ", "declarator", " at pos=", rx603_pos)
+    .return (rx603_cur)
+  rx603_restart:
 .annotate 'line', 4
-    (rx628_rep, rx628_pos, $I10, $P10) = rx628_cur."!mark_fail"(0)
-    lt rx628_pos, -1, rx628_done
-    eq rx628_pos, -1, rx628_fail
+    rx603_cur."!cursor_debug"("NEXT ", "declarator")
+  rx603_fail:
+    (rx603_rep, rx603_pos, $I10, $P10) = rx603_cur."!mark_fail"(0)
+    lt rx603_pos, -1, rx603_done
+    eq rx603_pos, -1, rx603_fail
     jump $I10
-  rx628_done:
-    rx628_cur."!cursor_fail"()
-    rx628_cur."!cursor_debug"("FAIL  ", "declarator")
-    .return (rx628_cur)
+  rx603_done:
+    rx603_cur."!cursor_fail"()
+    rx603_cur."!cursor_debug"("FAIL  ", "declarator")
+    .return (rx603_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__declarator"  :subid("151_1278500537.15927") :method
+.sub "!PREFIX__declarator"  :subid("151_1279529226.73787") :method
 .annotate 'line', 4
-    $P630 = self."!PREFIX__!subrule"("routine_declarator", "")
-    $P631 = self."!PREFIX__!subrule"("variable_declarator", "")
-    new $P632, "ResizablePMCArray"
-    push $P632, $P630
-    push $P632, $P631
-    .return ($P632)
+    $P605 = self."!PREFIX__!subrule"("routine_declarator", "")
+    $P606 = self."!PREFIX__!subrule"("variable_declarator", "")
+    new $P607, "ResizablePMCArray"
+    push $P607, $P605
+    push $P607, $P606
+    .return ($P607)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "variable_declarator"  :subid("152_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx636_tgt
-    .local int rx636_pos
-    .local int rx636_off
-    .local int rx636_eos
-    .local int rx636_rep
-    .local pmc rx636_cur
-    (rx636_cur, rx636_pos, rx636_tgt) = self."!cursor_start"()
-    rx636_cur."!cursor_debug"("START ", "variable_declarator")
-    .lex unicode:"$\x{a2}", rx636_cur
-    .local pmc match
-    .lex "$/", match
-    length rx636_eos, rx636_tgt
-    gt rx636_pos, rx636_eos, rx636_done
-    set rx636_off, 0
-    lt rx636_pos, 2, rx636_start
-    sub rx636_off, rx636_pos, 1
-    substr rx636_tgt, rx636_tgt, rx636_off
-  rx636_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan640_done
-    goto rxscan640_scan
-  rxscan640_loop:
-    ($P10) = rx636_cur."from"()
-    inc $P10
-    set rx636_pos, $P10
-    ge rx636_pos, rx636_eos, rxscan640_done
-  rxscan640_scan:
-    set_addr $I10, rxscan640_loop
-    rx636_cur."!mark_push"(0, rx636_pos, $I10)
-  rxscan640_done:
+.sub "variable_declarator"  :subid("152_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx611_tgt
+    .local int rx611_pos
+    .local int rx611_off
+    .local int rx611_eos
+    .local int rx611_rep
+    .local pmc rx611_cur
+    (rx611_cur, rx611_pos, rx611_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx611_cur
+    .local pmc match
+    .lex "$/", match
+    length rx611_eos, rx611_tgt
+    gt rx611_pos, rx611_eos, rx611_done
+    set rx611_off, 0
+    lt rx611_pos, 2, rx611_start
+    sub rx611_off, rx611_pos, 1
+    substr rx611_tgt, rx611_tgt, rx611_off
+  rx611_start:
+    eq $I10, 1, rx611_restart
+    rx611_cur."!cursor_debug"("START ", "variable_declarator")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan615_done
+    goto rxscan615_scan
+  rxscan615_loop:
+    ($P10) = rx611_cur."from"()
+    inc $P10
+    set rx611_pos, $P10
+    ge rx611_pos, rx611_eos, rxscan615_done
+  rxscan615_scan:
+    set_addr $I10, rxscan615_loop
+    rx611_cur."!mark_push"(0, rx611_pos, $I10)
+  rxscan615_done:
 .annotate 'line', 290
   # rx subrule "variable" subtype=capture negate=
-    rx636_cur."!cursor_pos"(rx636_pos)
-    $P10 = rx636_cur."variable"()
-    unless $P10, rx636_fail
-    rx636_cur."!mark_push"(0, -1, 0, $P10)
+    rx611_cur."!cursor_pos"(rx611_pos)
+    $P10 = rx611_cur."variable"()
+    unless $P10, rx611_fail
+    rx611_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("variable")
-    rx636_pos = $P10."pos"()
+    rx611_pos = $P10."pos"()
   # rx pass
-    rx636_cur."!cursor_pass"(rx636_pos, "variable_declarator")
-    rx636_cur."!cursor_debug"("PASS  ", "variable_declarator", " at pos=", rx636_pos)
-    .return (rx636_cur)
-  rx636_fail:
+    rx611_cur."!cursor_pass"(rx611_pos, "variable_declarator")
+    rx611_cur."!cursor_debug"("PASS  ", "variable_declarator", " at pos=", rx611_pos)
+    .return (rx611_cur)
+  rx611_restart:
 .annotate 'line', 4
-    (rx636_rep, rx636_pos, $I10, $P10) = rx636_cur."!mark_fail"(0)
-    lt rx636_pos, -1, rx636_done
-    eq rx636_pos, -1, rx636_fail
+    rx611_cur."!cursor_debug"("NEXT ", "variable_declarator")
+  rx611_fail:
+    (rx611_rep, rx611_pos, $I10, $P10) = rx611_cur."!mark_fail"(0)
+    lt rx611_pos, -1, rx611_done
+    eq rx611_pos, -1, rx611_fail
     jump $I10
-  rx636_done:
-    rx636_cur."!cursor_fail"()
-    rx636_cur."!cursor_debug"("FAIL  ", "variable_declarator")
-    .return (rx636_cur)
+  rx611_done:
+    rx611_cur."!cursor_fail"()
+    rx611_cur."!cursor_debug"("FAIL  ", "variable_declarator")
+    .return (rx611_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__variable_declarator"  :subid("153_1278500537.15927") :method
+.sub "!PREFIX__variable_declarator"  :subid("153_1279529226.73787") :method
 .annotate 'line', 4
-    $P638 = self."!PREFIX__!subrule"("variable", "")
-    new $P639, "ResizablePMCArray"
-    push $P639, $P638
-    .return ($P639)
+    $P613 = self."!PREFIX__!subrule"("variable", "")
+    new $P614, "ResizablePMCArray"
+    push $P614, $P613
+    .return ($P614)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "routine_declarator"  :subid("154_1278500537.15927") :method
+.sub "routine_declarator"  :subid("154_1279529226.73787") :method
 .annotate 'line', 292
-    $P642 = self."!protoregex"("routine_declarator")
-    .return ($P642)
+    $P617 = self."!protoregex"("routine_declarator")
+    .return ($P617)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__routine_declarator"  :subid("155_1278500537.15927") :method
+.sub "!PREFIX__routine_declarator"  :subid("155_1279529226.73787") :method
 .annotate 'line', 292
-    $P644 = self."!PREFIX__!protoregex"("routine_declarator")
-    .return ($P644)
+    $P619 = self."!PREFIX__!protoregex"("routine_declarator")
+    .return ($P619)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "routine_declarator:sym<sub>"  :subid("156_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "routine_declarator:sym<sub>"  :subid("156_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx646_tgt
-    .local int rx646_pos
-    .local int rx646_off
-    .local int rx646_eos
-    .local int rx646_rep
-    .local pmc rx646_cur
-    (rx646_cur, rx646_pos, rx646_tgt) = self."!cursor_start"()
-    rx646_cur."!cursor_debug"("START ", "routine_declarator:sym<sub>")
-    .lex unicode:"$\x{a2}", rx646_cur
-    .local pmc match
-    .lex "$/", match
-    length rx646_eos, rx646_tgt
-    gt rx646_pos, rx646_eos, rx646_done
-    set rx646_off, 0
-    lt rx646_pos, 2, rx646_start
-    sub rx646_off, rx646_pos, 1
-    substr rx646_tgt, rx646_tgt, rx646_off
-  rx646_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan650_done
-    goto rxscan650_scan
-  rxscan650_loop:
-    ($P10) = rx646_cur."from"()
-    inc $P10
-    set rx646_pos, $P10
-    ge rx646_pos, rx646_eos, rxscan650_done
-  rxscan650_scan:
-    set_addr $I10, rxscan650_loop
-    rx646_cur."!mark_push"(0, rx646_pos, $I10)
-  rxscan650_done:
+    .local string rx621_tgt
+    .local int rx621_pos
+    .local int rx621_off
+    .local int rx621_eos
+    .local int rx621_rep
+    .local pmc rx621_cur
+    (rx621_cur, rx621_pos, rx621_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx621_cur
+    .local pmc match
+    .lex "$/", match
+    length rx621_eos, rx621_tgt
+    gt rx621_pos, rx621_eos, rx621_done
+    set rx621_off, 0
+    lt rx621_pos, 2, rx621_start
+    sub rx621_off, rx621_pos, 1
+    substr rx621_tgt, rx621_tgt, rx621_off
+  rx621_start:
+    eq $I10, 1, rx621_restart
+    rx621_cur."!cursor_debug"("START ", "routine_declarator:sym<sub>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan625_done
+    goto rxscan625_scan
+  rxscan625_loop:
+    ($P10) = rx621_cur."from"()
+    inc $P10
+    set rx621_pos, $P10
+    ge rx621_pos, rx621_eos, rxscan625_done
+  rxscan625_scan:
+    set_addr $I10, rxscan625_loop
+    rx621_cur."!mark_push"(0, rx621_pos, $I10)
+  rxscan625_done:
 .annotate 'line', 293
   # rx subcapture "sym"
-    set_addr $I10, rxcap_651_fail
-    rx646_cur."!mark_push"(0, rx646_pos, $I10)
+    set_addr $I10, rxcap_626_fail
+    rx621_cur."!mark_push"(0, rx621_pos, $I10)
   # rx literal  "sub"
-    add $I11, rx646_pos, 3
-    gt $I11, rx646_eos, rx646_fail
-    sub $I11, rx646_pos, rx646_off
-    substr $S10, rx646_tgt, $I11, 3
-    ne $S10, "sub", rx646_fail
-    add rx646_pos, 3
-    set_addr $I10, rxcap_651_fail
-    ($I12, $I11) = rx646_cur."!mark_peek"($I10)
-    rx646_cur."!cursor_pos"($I11)
-    ($P10) = rx646_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx646_pos, "")
-    rx646_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx621_pos, 3
+    gt $I11, rx621_eos, rx621_fail
+    sub $I11, rx621_pos, rx621_off
+    substr $S10, rx621_tgt, $I11, 3
+    ne $S10, "sub", rx621_fail
+    add rx621_pos, 3
+    set_addr $I10, rxcap_626_fail
+    ($I12, $I11) = rx621_cur."!mark_peek"($I10)
+    rx621_cur."!cursor_pos"($I11)
+    ($P10) = rx621_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx621_pos, "")
+    rx621_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_651_done
-  rxcap_651_fail:
-    goto rx646_fail
-  rxcap_651_done:
+    goto rxcap_626_done
+  rxcap_626_fail:
+    goto rx621_fail
+  rxcap_626_done:
   # rx subrule "routine_def" subtype=capture negate=
-    rx646_cur."!cursor_pos"(rx646_pos)
-    $P10 = rx646_cur."routine_def"()
-    unless $P10, rx646_fail
-    rx646_cur."!mark_push"(0, -1, 0, $P10)
+    rx621_cur."!cursor_pos"(rx621_pos)
+    $P10 = rx621_cur."routine_def"()
+    unless $P10, rx621_fail
+    rx621_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("routine_def")
-    rx646_pos = $P10."pos"()
+    rx621_pos = $P10."pos"()
   # rx pass
-    rx646_cur."!cursor_pass"(rx646_pos, "routine_declarator:sym<sub>")
-    rx646_cur."!cursor_debug"("PASS  ", "routine_declarator:sym<sub>", " at pos=", rx646_pos)
-    .return (rx646_cur)
-  rx646_fail:
+    rx621_cur."!cursor_pass"(rx621_pos, "routine_declarator:sym<sub>")
+    rx621_cur."!cursor_debug"("PASS  ", "routine_declarator:sym<sub>", " at pos=", rx621_pos)
+    .return (rx621_cur)
+  rx621_restart:
 .annotate 'line', 4
-    (rx646_rep, rx646_pos, $I10, $P10) = rx646_cur."!mark_fail"(0)
-    lt rx646_pos, -1, rx646_done
-    eq rx646_pos, -1, rx646_fail
+    rx621_cur."!cursor_debug"("NEXT ", "routine_declarator:sym<sub>")
+  rx621_fail:
+    (rx621_rep, rx621_pos, $I10, $P10) = rx621_cur."!mark_fail"(0)
+    lt rx621_pos, -1, rx621_done
+    eq rx621_pos, -1, rx621_fail
     jump $I10
-  rx646_done:
-    rx646_cur."!cursor_fail"()
-    rx646_cur."!cursor_debug"("FAIL  ", "routine_declarator:sym<sub>")
-    .return (rx646_cur)
+  rx621_done:
+    rx621_cur."!cursor_fail"()
+    rx621_cur."!cursor_debug"("FAIL  ", "routine_declarator:sym<sub>")
+    .return (rx621_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__routine_declarator:sym<sub>"  :subid("157_1278500537.15927") :method
+.sub "!PREFIX__routine_declarator:sym<sub>"  :subid("157_1279529226.73787") :method
 .annotate 'line', 4
-    $P648 = self."!PREFIX__!subrule"("routine_def", "sub")
-    new $P649, "ResizablePMCArray"
-    push $P649, $P648
-    .return ($P649)
+    $P623 = self."!PREFIX__!subrule"("routine_def", "sub")
+    new $P624, "ResizablePMCArray"
+    push $P624, $P623
+    .return ($P624)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "routine_declarator:sym<method>"  :subid("158_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "routine_declarator:sym<method>"  :subid("158_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx653_tgt
-    .local int rx653_pos
-    .local int rx653_off
-    .local int rx653_eos
-    .local int rx653_rep
-    .local pmc rx653_cur
-    (rx653_cur, rx653_pos, rx653_tgt) = self."!cursor_start"()
-    rx653_cur."!cursor_debug"("START ", "routine_declarator:sym<method>")
-    .lex unicode:"$\x{a2}", rx653_cur
-    .local pmc match
-    .lex "$/", match
-    length rx653_eos, rx653_tgt
-    gt rx653_pos, rx653_eos, rx653_done
-    set rx653_off, 0
-    lt rx653_pos, 2, rx653_start
-    sub rx653_off, rx653_pos, 1
-    substr rx653_tgt, rx653_tgt, rx653_off
-  rx653_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan657_done
-    goto rxscan657_scan
-  rxscan657_loop:
-    ($P10) = rx653_cur."from"()
-    inc $P10
-    set rx653_pos, $P10
-    ge rx653_pos, rx653_eos, rxscan657_done
-  rxscan657_scan:
-    set_addr $I10, rxscan657_loop
-    rx653_cur."!mark_push"(0, rx653_pos, $I10)
-  rxscan657_done:
+    .local string rx628_tgt
+    .local int rx628_pos
+    .local int rx628_off
+    .local int rx628_eos
+    .local int rx628_rep
+    .local pmc rx628_cur
+    (rx628_cur, rx628_pos, rx628_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx628_cur
+    .local pmc match
+    .lex "$/", match
+    length rx628_eos, rx628_tgt
+    gt rx628_pos, rx628_eos, rx628_done
+    set rx628_off, 0
+    lt rx628_pos, 2, rx628_start
+    sub rx628_off, rx628_pos, 1
+    substr rx628_tgt, rx628_tgt, rx628_off
+  rx628_start:
+    eq $I10, 1, rx628_restart
+    rx628_cur."!cursor_debug"("START ", "routine_declarator:sym<method>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan632_done
+    goto rxscan632_scan
+  rxscan632_loop:
+    ($P10) = rx628_cur."from"()
+    inc $P10
+    set rx628_pos, $P10
+    ge rx628_pos, rx628_eos, rxscan632_done
+  rxscan632_scan:
+    set_addr $I10, rxscan632_loop
+    rx628_cur."!mark_push"(0, rx628_pos, $I10)
+  rxscan632_done:
 .annotate 'line', 294
   # rx subcapture "sym"
-    set_addr $I10, rxcap_658_fail
-    rx653_cur."!mark_push"(0, rx653_pos, $I10)
+    set_addr $I10, rxcap_633_fail
+    rx628_cur."!mark_push"(0, rx628_pos, $I10)
   # rx literal  "method"
-    add $I11, rx653_pos, 6
-    gt $I11, rx653_eos, rx653_fail
-    sub $I11, rx653_pos, rx653_off
-    substr $S10, rx653_tgt, $I11, 6
-    ne $S10, "method", rx653_fail
-    add rx653_pos, 6
-    set_addr $I10, rxcap_658_fail
-    ($I12, $I11) = rx653_cur."!mark_peek"($I10)
-    rx653_cur."!cursor_pos"($I11)
-    ($P10) = rx653_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx653_pos, "")
-    rx653_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx628_pos, 6
+    gt $I11, rx628_eos, rx628_fail
+    sub $I11, rx628_pos, rx628_off
+    substr $S10, rx628_tgt, $I11, 6
+    ne $S10, "method", rx628_fail
+    add rx628_pos, 6
+    set_addr $I10, rxcap_633_fail
+    ($I12, $I11) = rx628_cur."!mark_peek"($I10)
+    rx628_cur."!cursor_pos"($I11)
+    ($P10) = rx628_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx628_pos, "")
+    rx628_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_658_done
-  rxcap_658_fail:
-    goto rx653_fail
-  rxcap_658_done:
+    goto rxcap_633_done
+  rxcap_633_fail:
+    goto rx628_fail
+  rxcap_633_done:
   # rx subrule "method_def" subtype=capture negate=
-    rx653_cur."!cursor_pos"(rx653_pos)
-    $P10 = rx653_cur."method_def"()
-    unless $P10, rx653_fail
-    rx653_cur."!mark_push"(0, -1, 0, $P10)
+    rx628_cur."!cursor_pos"(rx628_pos)
+    $P10 = rx628_cur."method_def"()
+    unless $P10, rx628_fail
+    rx628_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("method_def")
-    rx653_pos = $P10."pos"()
+    rx628_pos = $P10."pos"()
   # rx pass
-    rx653_cur."!cursor_pass"(rx653_pos, "routine_declarator:sym<method>")
-    rx653_cur."!cursor_debug"("PASS  ", "routine_declarator:sym<method>", " at pos=", rx653_pos)
-    .return (rx653_cur)
-  rx653_fail:
+    rx628_cur."!cursor_pass"(rx628_pos, "routine_declarator:sym<method>")
+    rx628_cur."!cursor_debug"("PASS  ", "routine_declarator:sym<method>", " at pos=", rx628_pos)
+    .return (rx628_cur)
+  rx628_restart:
 .annotate 'line', 4
-    (rx653_rep, rx653_pos, $I10, $P10) = rx653_cur."!mark_fail"(0)
-    lt rx653_pos, -1, rx653_done
-    eq rx653_pos, -1, rx653_fail
+    rx628_cur."!cursor_debug"("NEXT ", "routine_declarator:sym<method>")
+  rx628_fail:
+    (rx628_rep, rx628_pos, $I10, $P10) = rx628_cur."!mark_fail"(0)
+    lt rx628_pos, -1, rx628_done
+    eq rx628_pos, -1, rx628_fail
     jump $I10
-  rx653_done:
-    rx653_cur."!cursor_fail"()
-    rx653_cur."!cursor_debug"("FAIL  ", "routine_declarator:sym<method>")
-    .return (rx653_cur)
+  rx628_done:
+    rx628_cur."!cursor_fail"()
+    rx628_cur."!cursor_debug"("FAIL  ", "routine_declarator:sym<method>")
+    .return (rx628_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__routine_declarator:sym<method>"  :subid("159_1278500537.15927") :method
+.sub "!PREFIX__routine_declarator:sym<method>"  :subid("159_1279529226.73787") :method
 .annotate 'line', 4
-    $P655 = self."!PREFIX__!subrule"("method_def", "method")
-    new $P656, "ResizablePMCArray"
-    push $P656, $P655
-    .return ($P656)
+    $P630 = self."!PREFIX__!subrule"("method_def", "method")
+    new $P631, "ResizablePMCArray"
+    push $P631, $P630
+    .return ($P631)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "routine_def"  :subid("160_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx660_tgt
-    .local int rx660_pos
-    .local int rx660_off
-    .local int rx660_eos
-    .local int rx660_rep
-    .local pmc rx660_cur
-    (rx660_cur, rx660_pos, rx660_tgt) = self."!cursor_start"()
-    rx660_cur."!cursor_debug"("START ", "routine_def")
-    rx660_cur."!cursor_caparray"("deflongname", "sigil")
-    .lex unicode:"$\x{a2}", rx660_cur
-    .local pmc match
-    .lex "$/", match
-    length rx660_eos, rx660_tgt
-    gt rx660_pos, rx660_eos, rx660_done
-    set rx660_off, 0
-    lt rx660_pos, 2, rx660_start
-    sub rx660_off, rx660_pos, 1
-    substr rx660_tgt, rx660_tgt, rx660_off
-  rx660_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan664_done
-    goto rxscan664_scan
-  rxscan664_loop:
-    ($P10) = rx660_cur."from"()
-    inc $P10
-    set rx660_pos, $P10
-    ge rx660_pos, rx660_eos, rxscan664_done
-  rxscan664_scan:
-    set_addr $I10, rxscan664_loop
-    rx660_cur."!mark_push"(0, rx660_pos, $I10)
-  rxscan664_done:
+.sub "routine_def"  :subid("160_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx635_tgt
+    .local int rx635_pos
+    .local int rx635_off
+    .local int rx635_eos
+    .local int rx635_rep
+    .local pmc rx635_cur
+    (rx635_cur, rx635_pos, rx635_tgt, $I10) = self."!cursor_start"()
+    rx635_cur."!cursor_caparray"("sigil", "deflongname")
+    .lex unicode:"$\x{a2}", rx635_cur
+    .local pmc match
+    .lex "$/", match
+    length rx635_eos, rx635_tgt
+    gt rx635_pos, rx635_eos, rx635_done
+    set rx635_off, 0
+    lt rx635_pos, 2, rx635_start
+    sub rx635_off, rx635_pos, 1
+    substr rx635_tgt, rx635_tgt, rx635_off
+  rx635_start:
+    eq $I10, 1, rx635_restart
+    rx635_cur."!cursor_debug"("START ", "routine_def")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan639_done
+    goto rxscan639_scan
+  rxscan639_loop:
+    ($P10) = rx635_cur."from"()
+    inc $P10
+    set rx635_pos, $P10
+    ge rx635_pos, rx635_eos, rxscan639_done
+  rxscan639_scan:
+    set_addr $I10, rxscan639_loop
+    rx635_cur."!mark_push"(0, rx635_pos, $I10)
+  rxscan639_done:
 .annotate 'line', 296
   # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
 .annotate 'line', 297
-  # rx rxquantr666 ** 0..1
-    set_addr $I672, rxquantr666_done
-    rx660_cur."!mark_push"(0, rx660_pos, $I672)
-  rxquantr666_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+  # rx rxquantr641 ** 0..1
+    set_addr $I10, rxquantr641_done
+    rx635_cur."!mark_push"(0, rx635_pos, $I10)
+  rxquantr641_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
   # rx subcapture "sigil"
-    set_addr $I10, rxcap_670_fail
-    rx660_cur."!mark_push"(0, rx660_pos, $I10)
-  # rx rxquantr668 ** 0..1
-    set_addr $I669, rxquantr668_done
-    rx660_cur."!mark_push"(0, rx660_pos, $I669)
-  rxquantr668_loop:
+    set_addr $I10, rxcap_644_fail
+    rx635_cur."!mark_push"(0, rx635_pos, $I10)
+  # rx rxquantr643 ** 0..1
+    set_addr $I10, rxquantr643_done
+    rx635_cur."!mark_push"(0, rx635_pos, $I10)
+  rxquantr643_loop:
   # rx literal  "&"
-    add $I11, rx660_pos, 1
-    gt $I11, rx660_eos, rx660_fail
-    sub $I11, rx660_pos, rx660_off
-    substr $S10, rx660_tgt, $I11, 1
-    ne $S10, "&", rx660_fail
-    add rx660_pos, 1
-    (rx660_rep) = rx660_cur."!mark_commit"($I669)
-  rxquantr668_done:
-    set_addr $I10, rxcap_670_fail
-    ($I12, $I11) = rx660_cur."!mark_peek"($I10)
-    rx660_cur."!cursor_pos"($I11)
-    ($P10) = rx660_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx660_pos, "")
-    rx660_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx635_pos, 1
+    gt $I11, rx635_eos, rx635_fail
+    sub $I11, rx635_pos, rx635_off
+    substr $S10, rx635_tgt, $I11, 1
+    ne $S10, "&", rx635_fail
+    add rx635_pos, 1
+    set_addr $I10, rxquantr643_done
+    (rx635_rep) = rx635_cur."!mark_commit"($I10)
+  rxquantr643_done:
+    set_addr $I10, rxcap_644_fail
+    ($I12, $I11) = rx635_cur."!mark_peek"($I10)
+    rx635_cur."!cursor_pos"($I11)
+    ($P10) = rx635_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx635_pos, "")
+    rx635_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sigil")
-    goto rxcap_670_done
-  rxcap_670_fail:
-    goto rx660_fail
-  rxcap_670_done:
+    goto rxcap_644_done
+  rxcap_644_fail:
+    goto rx635_fail
+  rxcap_644_done:
   # rx subrule "deflongname" subtype=capture negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."deflongname"()
-    unless $P10, rx660_fail
-    rx660_cur."!mark_push"(0, -1, 0, $P10)
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."deflongname"()
+    unless $P10, rx635_fail
+    rx635_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("deflongname")
-    rx660_pos = $P10."pos"()
+    rx635_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
-    (rx660_rep) = rx660_cur."!mark_commit"($I672)
-  rxquantr666_done:
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
+    set_addr $I10, rxquantr641_done
+    (rx635_rep) = rx635_cur."!mark_commit"($I10)
+  rxquantr641_done:
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
 .annotate 'line', 298
   # rx subrule "newpad" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."newpad"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
-  alt675_0:
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."newpad"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
+  alt648_0:
 .annotate 'line', 299
-    set_addr $I10, alt675_1
-    rx660_cur."!mark_push"(0, rx660_pos, $I10)
+    set_addr $I10, alt648_1
+    rx635_cur."!mark_push"(0, rx635_pos, $I10)
   # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
   # rx literal  "("
-    add $I11, rx660_pos, 1
-    gt $I11, rx660_eos, rx660_fail
-    sub $I11, rx660_pos, rx660_off
-    substr $S10, rx660_tgt, $I11, 1
-    ne $S10, "(", rx660_fail
-    add rx660_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    add $I11, rx635_pos, 1
+    gt $I11, rx635_eos, rx635_fail
+    sub $I11, rx635_pos, rx635_off
+    substr $S10, rx635_tgt, $I11, 1
+    ne $S10, "(", rx635_fail
+    add rx635_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
   # rx subrule "signature" subtype=capture negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."signature"()
-    unless $P10, rx660_fail
-    rx660_cur."!mark_push"(0, -1, 0, $P10)
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."signature"()
+    unless $P10, rx635_fail
+    rx635_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("signature")
-    rx660_pos = $P10."pos"()
+    rx635_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx660_pos, 1
-    gt $I11, rx660_eos, rx660_fail
-    sub $I11, rx660_pos, rx660_off
-    substr $S10, rx660_tgt, $I11, 1
-    ne $S10, ")", rx660_fail
-    add rx660_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
-    goto alt675_end
-  alt675_1:
+    add $I11, rx635_pos, 1
+    gt $I11, rx635_eos, rx635_fail
+    sub $I11, rx635_pos, rx635_off
+    substr $S10, rx635_tgt, $I11, 1
+    ne $S10, ")", rx635_fail
+    add rx635_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
+    goto alt648_end
+  alt648_1:
 .annotate 'line', 300
   # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
   # rx subrule "panic" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."panic"("Routine declaration requires a signature")
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
-  alt675_end:
-  # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."panic"("Routine declaration requires a signature")
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
+  alt648_end:
+  # rx subrule "ws" subtype=method negate=
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
 .annotate 'line', 301
   # rx subrule "blockoid" subtype=capture negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."blockoid"()
-    unless $P10, rx660_fail
-    rx660_cur."!mark_push"(0, -1, 0, $P10)
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."blockoid"()
+    unless $P10, rx635_fail
+    rx635_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blockoid")
-    rx660_pos = $P10."pos"()
+    rx635_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx660_cur."!cursor_pos"(rx660_pos)
-    $P10 = rx660_cur."ws"()
-    unless $P10, rx660_fail
-    rx660_pos = $P10."pos"()
+    rx635_cur."!cursor_pos"(rx635_pos)
+    $P10 = rx635_cur."ws"()
+    unless $P10, rx635_fail
+    rx635_pos = $P10."pos"()
 .annotate 'line', 296
   # rx pass
-    rx660_cur."!cursor_pass"(rx660_pos, "routine_def")
-    rx660_cur."!cursor_debug"("PASS  ", "routine_def", " at pos=", rx660_pos)
-    .return (rx660_cur)
-  rx660_fail:
+    rx635_cur."!cursor_pass"(rx635_pos, "routine_def")
+    rx635_cur."!cursor_debug"("PASS  ", "routine_def", " at pos=", rx635_pos)
+    .return (rx635_cur)
+  rx635_restart:
 .annotate 'line', 4
-    (rx660_rep, rx660_pos, $I10, $P10) = rx660_cur."!mark_fail"(0)
-    lt rx660_pos, -1, rx660_done
-    eq rx660_pos, -1, rx660_fail
+    rx635_cur."!cursor_debug"("NEXT ", "routine_def")
+  rx635_fail:
+    (rx635_rep, rx635_pos, $I10, $P10) = rx635_cur."!mark_fail"(0)
+    lt rx635_pos, -1, rx635_done
+    eq rx635_pos, -1, rx635_fail
     jump $I10
-  rx660_done:
-    rx660_cur."!cursor_fail"()
-    rx660_cur."!cursor_debug"("FAIL  ", "routine_def")
-    .return (rx660_cur)
+  rx635_done:
+    rx635_cur."!cursor_fail"()
+    rx635_cur."!cursor_debug"("FAIL  ", "routine_def")
+    .return (rx635_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__routine_def"  :subid("161_1278500537.15927") :method
+.sub "!PREFIX__routine_def"  :subid("161_1279529226.73787") :method
 .annotate 'line', 4
-    $P662 = self."!PREFIX__!subrule"("ws", "")
-    new $P663, "ResizablePMCArray"
-    push $P663, $P662
-    .return ($P663)
+    $P637 = self."!PREFIX__!subrule"("ws", "")
+    new $P638, "ResizablePMCArray"
+    push $P638, $P637
+    .return ($P638)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "method_def"  :subid("162_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "method_def"  :subid("162_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx685_tgt
-    .local int rx685_pos
-    .local int rx685_off
-    .local int rx685_eos
-    .local int rx685_rep
-    .local pmc rx685_cur
-    (rx685_cur, rx685_pos, rx685_tgt) = self."!cursor_start"()
-    rx685_cur."!cursor_debug"("START ", "method_def")
-    rx685_cur."!cursor_caparray"("deflongname")
-    .lex unicode:"$\x{a2}", rx685_cur
+    .local string rx658_tgt
+    .local int rx658_pos
+    .local int rx658_off
+    .local int rx658_eos
+    .local int rx658_rep
+    .local pmc rx658_cur
+    (rx658_cur, rx658_pos, rx658_tgt, $I10) = self."!cursor_start"()
+    rx658_cur."!cursor_caparray"("deflongname")
+    .lex unicode:"$\x{a2}", rx658_cur
     .local pmc match
     .lex "$/", match
-    length rx685_eos, rx685_tgt
-    gt rx685_pos, rx685_eos, rx685_done
-    set rx685_off, 0
-    lt rx685_pos, 2, rx685_start
-    sub rx685_off, rx685_pos, 1
-    substr rx685_tgt, rx685_tgt, rx685_off
-  rx685_start:
+    length rx658_eos, rx658_tgt
+    gt rx658_pos, rx658_eos, rx658_done
+    set rx658_off, 0
+    lt rx658_pos, 2, rx658_start
+    sub rx658_off, rx658_pos, 1
+    substr rx658_tgt, rx658_tgt, rx658_off
+  rx658_start:
+    eq $I10, 1, rx658_restart
+    rx658_cur."!cursor_debug"("START ", "method_def")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan689_done
-    goto rxscan689_scan
-  rxscan689_loop:
-    ($P10) = rx685_cur."from"()
+    ne $I10, -1, rxscan662_done
+    goto rxscan662_scan
+  rxscan662_loop:
+    ($P10) = rx658_cur."from"()
     inc $P10
-    set rx685_pos, $P10
-    ge rx685_pos, rx685_eos, rxscan689_done
-  rxscan689_scan:
-    set_addr $I10, rxscan689_loop
-    rx685_cur."!mark_push"(0, rx685_pos, $I10)
-  rxscan689_done:
+    set rx658_pos, $P10
+    ge rx658_pos, rx658_eos, rxscan662_done
+  rxscan662_scan:
+    set_addr $I10, rxscan662_loop
+    rx658_cur."!mark_push"(0, rx658_pos, $I10)
+  rxscan662_done:
 .annotate 'line', 304
   # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
 .annotate 'line', 305
-  # rx rxquantr691 ** 0..1
-    set_addr $I692, rxquantr691_done
-    rx685_cur."!mark_push"(0, rx685_pos, $I692)
-  rxquantr691_loop:
+  # rx rxquantr664 ** 0..1
+    set_addr $I10, rxquantr664_done
+    rx658_cur."!mark_push"(0, rx658_pos, $I10)
+  rxquantr664_loop:
   # rx subrule "deflongname" subtype=capture negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."deflongname"()
-    unless $P10, rx685_fail
-    rx685_cur."!mark_push"(0, -1, 0, $P10)
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."deflongname"()
+    unless $P10, rx658_fail
+    goto rxsubrule665_pass
+  rxsubrule665_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx658_fail
+  rxsubrule665_pass:
+    set_addr $I10, rxsubrule665_back
+    rx658_cur."!mark_push"(0, rx658_pos, $I10, $P10)
     $P10."!cursor_names"("deflongname")
-    rx685_pos = $P10."pos"()
-    (rx685_rep) = rx685_cur."!mark_commit"($I692)
-  rxquantr691_done:
-  # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_pos = $P10."pos"()
+    set_addr $I10, rxquantr664_done
+    (rx658_rep) = rx658_cur."!mark_commit"($I10)
+  rxquantr664_done:
+  # rx subrule "ws" subtype=method negate=
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
 .annotate 'line', 306
   # rx subrule "newpad" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."newpad"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
-  alt695_0:
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."newpad"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
+  alt668_0:
 .annotate 'line', 307
-    set_addr $I10, alt695_1
-    rx685_cur."!mark_push"(0, rx685_pos, $I10)
+    set_addr $I10, alt668_1
+    rx658_cur."!mark_push"(0, rx658_pos, $I10)
   # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
   # rx literal  "("
-    add $I11, rx685_pos, 1
-    gt $I11, rx685_eos, rx685_fail
-    sub $I11, rx685_pos, rx685_off
-    substr $S10, rx685_tgt, $I11, 1
-    ne $S10, "(", rx685_fail
-    add rx685_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    add $I11, rx658_pos, 1
+    gt $I11, rx658_eos, rx658_fail
+    sub $I11, rx658_pos, rx658_off
+    substr $S10, rx658_tgt, $I11, 1
+    ne $S10, "(", rx658_fail
+    add rx658_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
   # rx subrule "signature" subtype=capture negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."signature"()
-    unless $P10, rx685_fail
-    rx685_cur."!mark_push"(0, -1, 0, $P10)
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."signature"()
+    unless $P10, rx658_fail
+    rx658_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("signature")
-    rx685_pos = $P10."pos"()
+    rx658_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx685_pos, 1
-    gt $I11, rx685_eos, rx685_fail
-    sub $I11, rx685_pos, rx685_off
-    substr $S10, rx685_tgt, $I11, 1
-    ne $S10, ")", rx685_fail
-    add rx685_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
-    goto alt695_end
-  alt695_1:
+    add $I11, rx658_pos, 1
+    gt $I11, rx658_eos, rx658_fail
+    sub $I11, rx658_pos, rx658_off
+    substr $S10, rx658_tgt, $I11, 1
+    ne $S10, ")", rx658_fail
+    add rx658_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
+    goto alt668_end
+  alt668_1:
 .annotate 'line', 308
   # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
   # rx subrule "panic" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."panic"("Routine declaration requires a signature")
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
-  alt695_end:
-  # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."panic"("Routine declaration requires a signature")
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
+  alt668_end:
+  # rx subrule "ws" subtype=method negate=
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
 .annotate 'line', 309
   # rx subrule "blockoid" subtype=capture negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."blockoid"()
-    unless $P10, rx685_fail
-    rx685_cur."!mark_push"(0, -1, 0, $P10)
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."blockoid"()
+    unless $P10, rx658_fail
+    rx658_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("blockoid")
-    rx685_pos = $P10."pos"()
+    rx658_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx685_cur."!cursor_pos"(rx685_pos)
-    $P10 = rx685_cur."ws"()
-    unless $P10, rx685_fail
-    rx685_pos = $P10."pos"()
+    rx658_cur."!cursor_pos"(rx658_pos)
+    $P10 = rx658_cur."ws"()
+    unless $P10, rx658_fail
+    rx658_pos = $P10."pos"()
 .annotate 'line', 304
   # rx pass
-    rx685_cur."!cursor_pass"(rx685_pos, "method_def")
-    rx685_cur."!cursor_debug"("PASS  ", "method_def", " at pos=", rx685_pos)
-    .return (rx685_cur)
-  rx685_fail:
+    rx658_cur."!cursor_pass"(rx658_pos, "method_def")
+    rx658_cur."!cursor_debug"("PASS  ", "method_def", " at pos=", rx658_pos)
+    .return (rx658_cur)
+  rx658_restart:
 .annotate 'line', 4
-    (rx685_rep, rx685_pos, $I10, $P10) = rx685_cur."!mark_fail"(0)
-    lt rx685_pos, -1, rx685_done
-    eq rx685_pos, -1, rx685_fail
+    rx658_cur."!cursor_debug"("NEXT ", "method_def")
+  rx658_fail:
+    (rx658_rep, rx658_pos, $I10, $P10) = rx658_cur."!mark_fail"(0)
+    lt rx658_pos, -1, rx658_done
+    eq rx658_pos, -1, rx658_fail
     jump $I10
-  rx685_done:
-    rx685_cur."!cursor_fail"()
-    rx685_cur."!cursor_debug"("FAIL  ", "method_def")
-    .return (rx685_cur)
+  rx658_done:
+    rx658_cur."!cursor_fail"()
+    rx658_cur."!cursor_debug"("FAIL  ", "method_def")
+    .return (rx658_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__method_def"  :subid("163_1278500537.15927") :method
+.sub "!PREFIX__method_def"  :subid("163_1279529226.73787") :method
 .annotate 'line', 4
-    $P687 = self."!PREFIX__!subrule"("ws", "")
-    new $P688, "ResizablePMCArray"
-    push $P688, $P687
-    .return ($P688)
+    $P660 = self."!PREFIX__!subrule"("ws", "")
+    new $P661, "ResizablePMCArray"
+    push $P661, $P660
+    .return ($P661)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "multi_declarator"  :subid("164_1278500537.15927") :method
+.sub "multi_declarator"  :subid("164_1279529226.73787") :method
 .annotate 'line', 312
-    $P705 = self."!protoregex"("multi_declarator")
-    .return ($P705)
+    $P678 = self."!protoregex"("multi_declarator")
+    .return ($P678)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__multi_declarator"  :subid("165_1278500537.15927") :method
+.sub "!PREFIX__multi_declarator"  :subid("165_1279529226.73787") :method
 .annotate 'line', 312
-    $P707 = self."!PREFIX__!protoregex"("multi_declarator")
-    .return ($P707)
+    $P680 = self."!PREFIX__!protoregex"("multi_declarator")
+    .return ($P680)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "multi_declarator:sym<multi>"  :subid("166_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "multi_declarator:sym<multi>"  :subid("166_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 314
-    new $P709, "Undef"
-    .lex "$*MULTINESS", $P709
+    new $P682, "Undef"
+    .lex "$*MULTINESS", $P682
 .annotate 'line', 4
-    .local string rx710_tgt
-    .local int rx710_pos
-    .local int rx710_off
-    .local int rx710_eos
-    .local int rx710_rep
-    .local pmc rx710_cur
-    (rx710_cur, rx710_pos, rx710_tgt) = self."!cursor_start"()
-    rx710_cur."!cursor_debug"("START ", "multi_declarator:sym<multi>")
-    .lex unicode:"$\x{a2}", rx710_cur
-    .local pmc match
-    .lex "$/", match
-    length rx710_eos, rx710_tgt
-    gt rx710_pos, rx710_eos, rx710_done
-    set rx710_off, 0
-    lt rx710_pos, 2, rx710_start
-    sub rx710_off, rx710_pos, 1
-    substr rx710_tgt, rx710_tgt, rx710_off
-  rx710_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan714_done
-    goto rxscan714_scan
-  rxscan714_loop:
-    ($P10) = rx710_cur."from"()
-    inc $P10
-    set rx710_pos, $P10
-    ge rx710_pos, rx710_eos, rxscan714_done
-  rxscan714_scan:
-    set_addr $I10, rxscan714_loop
-    rx710_cur."!mark_push"(0, rx710_pos, $I10)
-  rxscan714_done:
+    .local string rx683_tgt
+    .local int rx683_pos
+    .local int rx683_off
+    .local int rx683_eos
+    .local int rx683_rep
+    .local pmc rx683_cur
+    (rx683_cur, rx683_pos, rx683_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx683_cur
+    .local pmc match
+    .lex "$/", match
+    length rx683_eos, rx683_tgt
+    gt rx683_pos, rx683_eos, rx683_done
+    set rx683_off, 0
+    lt rx683_pos, 2, rx683_start
+    sub rx683_off, rx683_pos, 1
+    substr rx683_tgt, rx683_tgt, rx683_off
+  rx683_start:
+    eq $I10, 1, rx683_restart
+    rx683_cur."!cursor_debug"("START ", "multi_declarator:sym<multi>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan687_done
+    goto rxscan687_scan
+  rxscan687_loop:
+    ($P10) = rx683_cur."from"()
+    inc $P10
+    set rx683_pos, $P10
+    ge rx683_pos, rx683_eos, rxscan687_done
+  rxscan687_scan:
+    set_addr $I10, rxscan687_loop
+    rx683_cur."!mark_push"(0, rx683_pos, $I10)
+  rxscan687_done:
 .annotate 'line', 314
-    rx710_cur."!cursor_pos"(rx710_pos)
-    new $P715, "String"
-    assign $P715, "multi"
-    store_lex "$*MULTINESS", $P715
+    rx683_cur."!cursor_pos"(rx683_pos)
+    new $P688, "String"
+    assign $P688, "multi"
+    store_lex "$*MULTINESS", $P688
 .annotate 'line', 315
   # rx subcapture "sym"
-    set_addr $I10, rxcap_716_fail
-    rx710_cur."!mark_push"(0, rx710_pos, $I10)
+    set_addr $I10, rxcap_689_fail
+    rx683_cur."!mark_push"(0, rx683_pos, $I10)
   # rx literal  "multi"
-    add $I11, rx710_pos, 5
-    gt $I11, rx710_eos, rx710_fail
-    sub $I11, rx710_pos, rx710_off
-    substr $S10, rx710_tgt, $I11, 5
-    ne $S10, "multi", rx710_fail
-    add rx710_pos, 5
-    set_addr $I10, rxcap_716_fail
-    ($I12, $I11) = rx710_cur."!mark_peek"($I10)
-    rx710_cur."!cursor_pos"($I11)
-    ($P10) = rx710_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx710_pos, "")
-    rx710_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx683_pos, 5
+    gt $I11, rx683_eos, rx683_fail
+    sub $I11, rx683_pos, rx683_off
+    substr $S10, rx683_tgt, $I11, 5
+    ne $S10, "multi", rx683_fail
+    add rx683_pos, 5
+    set_addr $I10, rxcap_689_fail
+    ($I12, $I11) = rx683_cur."!mark_peek"($I10)
+    rx683_cur."!cursor_pos"($I11)
+    ($P10) = rx683_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx683_pos, "")
+    rx683_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_716_done
-  rxcap_716_fail:
-    goto rx710_fail
-  rxcap_716_done:
+    goto rxcap_689_done
+  rxcap_689_fail:
+    goto rx683_fail
+  rxcap_689_done:
 .annotate 'line', 316
   # rx subrule "ws" subtype=method negate=
-    rx710_cur."!cursor_pos"(rx710_pos)
-    $P10 = rx710_cur."ws"()
-    unless $P10, rx710_fail
-    rx710_pos = $P10."pos"()
-  alt717_0:
-    set_addr $I10, alt717_1
-    rx710_cur."!mark_push"(0, rx710_pos, $I10)
+    rx683_cur."!cursor_pos"(rx683_pos)
+    $P10 = rx683_cur."ws"()
+    unless $P10, rx683_fail
+    rx683_pos = $P10."pos"()
+  alt690_0:
+    set_addr $I10, alt690_1
+    rx683_cur."!mark_push"(0, rx683_pos, $I10)
   # rx subrule "declarator" subtype=capture negate=
-    rx710_cur."!cursor_pos"(rx710_pos)
-    $P10 = rx710_cur."declarator"()
-    unless $P10, rx710_fail
-    rx710_cur."!mark_push"(0, -1, 0, $P10)
+    rx683_cur."!cursor_pos"(rx683_pos)
+    $P10 = rx683_cur."declarator"()
+    unless $P10, rx683_fail
+    rx683_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("declarator")
-    rx710_pos = $P10."pos"()
-    goto alt717_end
-  alt717_1:
-    set_addr $I10, alt717_2
-    rx710_cur."!mark_push"(0, rx710_pos, $I10)
+    rx683_pos = $P10."pos"()
+    goto alt690_end
+  alt690_1:
+    set_addr $I10, alt690_2
+    rx683_cur."!mark_push"(0, rx683_pos, $I10)
   # rx subrule "routine_def" subtype=capture negate=
-    rx710_cur."!cursor_pos"(rx710_pos)
-    $P10 = rx710_cur."routine_def"()
-    unless $P10, rx710_fail
-    rx710_cur."!mark_push"(0, -1, 0, $P10)
+    rx683_cur."!cursor_pos"(rx683_pos)
+    $P10 = rx683_cur."routine_def"()
+    unless $P10, rx683_fail
+    rx683_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("routine_def")
-    rx710_pos = $P10."pos"()
-    goto alt717_end
-  alt717_2:
+    rx683_pos = $P10."pos"()
+    goto alt690_end
+  alt690_2:
   # rx subrule "panic" subtype=method negate=
-    rx710_cur."!cursor_pos"(rx710_pos)
-    $P10 = rx710_cur."panic"("Malformed multi")
-    unless $P10, rx710_fail
-    rx710_pos = $P10."pos"()
-  alt717_end:
+    rx683_cur."!cursor_pos"(rx683_pos)
+    $P10 = rx683_cur."panic"("Malformed multi")
+    unless $P10, rx683_fail
+    rx683_pos = $P10."pos"()
+  alt690_end:
 .annotate 'line', 313
   # rx pass
-    rx710_cur."!cursor_pass"(rx710_pos, "multi_declarator:sym<multi>")
-    rx710_cur."!cursor_debug"("PASS  ", "multi_declarator:sym<multi>", " at pos=", rx710_pos)
-    .return (rx710_cur)
-  rx710_fail:
+    rx683_cur."!cursor_pass"(rx683_pos, "multi_declarator:sym<multi>")
+    rx683_cur."!cursor_debug"("PASS  ", "multi_declarator:sym<multi>", " at pos=", rx683_pos)
+    .return (rx683_cur)
+  rx683_restart:
 .annotate 'line', 4
-    (rx710_rep, rx710_pos, $I10, $P10) = rx710_cur."!mark_fail"(0)
-    lt rx710_pos, -1, rx710_done
-    eq rx710_pos, -1, rx710_fail
+    rx683_cur."!cursor_debug"("NEXT ", "multi_declarator:sym<multi>")
+  rx683_fail:
+    (rx683_rep, rx683_pos, $I10, $P10) = rx683_cur."!mark_fail"(0)
+    lt rx683_pos, -1, rx683_done
+    eq rx683_pos, -1, rx683_fail
     jump $I10
-  rx710_done:
-    rx710_cur."!cursor_fail"()
-    rx710_cur."!cursor_debug"("FAIL  ", "multi_declarator:sym<multi>")
-    .return (rx710_cur)
+  rx683_done:
+    rx683_cur."!cursor_fail"()
+    rx683_cur."!cursor_debug"("FAIL  ", "multi_declarator:sym<multi>")
+    .return (rx683_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__multi_declarator:sym<multi>"  :subid("167_1278500537.15927") :method
+.sub "!PREFIX__multi_declarator:sym<multi>"  :subid("167_1279529226.73787") :method
 .annotate 'line', 4
-    $P712 = self."!PREFIX__!subrule"("ws", "multi")
-    new $P713, "ResizablePMCArray"
-    push $P713, $P712
-    .return ($P713)
+    $P685 = self."!PREFIX__!subrule"("ws", "multi")
+    new $P686, "ResizablePMCArray"
+    push $P686, $P685
+    .return ($P686)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "multi_declarator:sym<null>"  :subid("168_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "multi_declarator:sym<null>"  :subid("168_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 319
+    new $P692, "Undef"
+    .lex "$*MULTINESS", $P692
+.annotate 'line', 4
+    .local string rx693_tgt
+    .local int rx693_pos
+    .local int rx693_off
+    .local int rx693_eos
+    .local int rx693_rep
+    .local pmc rx693_cur
+    (rx693_cur, rx693_pos, rx693_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx693_cur
+    .local pmc match
+    .lex "$/", match
+    length rx693_eos, rx693_tgt
+    gt rx693_pos, rx693_eos, rx693_done
+    set rx693_off, 0
+    lt rx693_pos, 2, rx693_start
+    sub rx693_off, rx693_pos, 1
+    substr rx693_tgt, rx693_tgt, rx693_off
+  rx693_start:
+    eq $I10, 1, rx693_restart
+    rx693_cur."!cursor_debug"("START ", "multi_declarator:sym<null>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan697_done
+    goto rxscan697_scan
+  rxscan697_loop:
+    ($P10) = rx693_cur."from"()
+    inc $P10
+    set rx693_pos, $P10
+    ge rx693_pos, rx693_eos, rxscan697_done
+  rxscan697_scan:
+    set_addr $I10, rxscan697_loop
+    rx693_cur."!mark_push"(0, rx693_pos, $I10)
+  rxscan697_done:
 .annotate 'line', 319
-    new $P719, "Undef"
-    .lex "$*MULTINESS", $P719
+    rx693_cur."!cursor_pos"(rx693_pos)
+    new $P698, "String"
+    assign $P698, ""
+    store_lex "$*MULTINESS", $P698
+.annotate 'line', 320
+  # rx subrule "declarator" subtype=capture negate=
+    rx693_cur."!cursor_pos"(rx693_pos)
+    $P10 = rx693_cur."declarator"()
+    unless $P10, rx693_fail
+    rx693_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("declarator")
+    rx693_pos = $P10."pos"()
+.annotate 'line', 318
+  # rx pass
+    rx693_cur."!cursor_pass"(rx693_pos, "multi_declarator:sym<null>")
+    rx693_cur."!cursor_debug"("PASS  ", "multi_declarator:sym<null>", " at pos=", rx693_pos)
+    .return (rx693_cur)
+  rx693_restart:
+.annotate 'line', 4
+    rx693_cur."!cursor_debug"("NEXT ", "multi_declarator:sym<null>")
+  rx693_fail:
+    (rx693_rep, rx693_pos, $I10, $P10) = rx693_cur."!mark_fail"(0)
+    lt rx693_pos, -1, rx693_done
+    eq rx693_pos, -1, rx693_fail
+    jump $I10
+  rx693_done:
+    rx693_cur."!cursor_fail"()
+    rx693_cur."!cursor_debug"("FAIL  ", "multi_declarator:sym<null>")
+    .return (rx693_cur)
+    .return ()
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "!PREFIX__multi_declarator:sym<null>"  :subid("169_1279529226.73787") :method
+.annotate 'line', 4
+    $P695 = self."!PREFIX__!subrule"("declarator", "")
+    new $P696, "ResizablePMCArray"
+    push $P696, $P695
+    .return ($P696)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "signature"  :subid("170_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx700_tgt
+    .local int rx700_pos
+    .local int rx700_off
+    .local int rx700_eos
+    .local int rx700_rep
+    .local pmc rx700_cur
+    (rx700_cur, rx700_pos, rx700_tgt, $I10) = self."!cursor_start"()
+    rx700_cur."!cursor_caparray"("parameter")
+    .lex unicode:"$\x{a2}", rx700_cur
+    .local pmc match
+    .lex "$/", match
+    length rx700_eos, rx700_tgt
+    gt rx700_pos, rx700_eos, rx700_done
+    set rx700_off, 0
+    lt rx700_pos, 2, rx700_start
+    sub rx700_off, rx700_pos, 1
+    substr rx700_tgt, rx700_tgt, rx700_off
+  rx700_start:
+    eq $I10, 1, rx700_restart
+    rx700_cur."!cursor_debug"("START ", "signature")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan703_done
+    goto rxscan703_scan
+  rxscan703_loop:
+    ($P10) = rx700_cur."from"()
+    inc $P10
+    set rx700_pos, $P10
+    ge rx700_pos, rx700_eos, rxscan703_done
+  rxscan703_scan:
+    set_addr $I10, rxscan703_loop
+    rx700_cur."!mark_push"(0, rx700_pos, $I10)
+  rxscan703_done:
+.annotate 'line', 323
+  # rx rxquantr704 ** 0..1
+    set_addr $I10, rxquantr704_done
+    rx700_cur."!mark_push"(0, rx700_pos, $I10)
+  rxquantr704_loop:
+  # rx rxquantr705 ** 1..*
+    set_addr $I10, rxquantr705_done
+    rx700_cur."!mark_push"(0, -1, $I10)
+  rxquantr705_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx700_cur."!cursor_pos"(rx700_pos)
+    $P10 = rx700_cur."ws"()
+    unless $P10, rx700_fail
+    rx700_pos = $P10."pos"()
+  # rx subrule "parameter" subtype=capture negate=
+    rx700_cur."!cursor_pos"(rx700_pos)
+    $P10 = rx700_cur."parameter"()
+    unless $P10, rx700_fail
+    rx700_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("parameter")
+    rx700_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx700_cur."!cursor_pos"(rx700_pos)
+    $P10 = rx700_cur."ws"()
+    unless $P10, rx700_fail
+    rx700_pos = $P10."pos"()
+    set_addr $I10, rxquantr705_done
+    (rx700_rep) = rx700_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr705_done
+    rx700_cur."!mark_push"(rx700_rep, rx700_pos, $I10)
+  # rx literal  ","
+    add $I11, rx700_pos, 1
+    gt $I11, rx700_eos, rx700_fail
+    sub $I11, rx700_pos, rx700_off
+    substr $S10, rx700_tgt, $I11, 1
+    ne $S10, ",", rx700_fail
+    add rx700_pos, 1
+    goto rxquantr705_loop
+  rxquantr705_done:
+    set_addr $I10, rxquantr704_done
+    (rx700_rep) = rx700_cur."!mark_commit"($I10)
+  rxquantr704_done:
+  # rx pass
+    rx700_cur."!cursor_pass"(rx700_pos, "signature")
+    rx700_cur."!cursor_debug"("PASS  ", "signature", " at pos=", rx700_pos)
+    .return (rx700_cur)
+  rx700_restart:
+.annotate 'line', 4
+    rx700_cur."!cursor_debug"("NEXT ", "signature")
+  rx700_fail:
+    (rx700_rep, rx700_pos, $I10, $P10) = rx700_cur."!mark_fail"(0)
+    lt rx700_pos, -1, rx700_done
+    eq rx700_pos, -1, rx700_fail
+    jump $I10
+  rx700_done:
+    rx700_cur."!cursor_fail"()
+    rx700_cur."!cursor_debug"("FAIL  ", "signature")
+    .return (rx700_cur)
+    .return ()
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "!PREFIX__signature"  :subid("171_1279529226.73787") :method
+.annotate 'line', 4
+    new $P702, "ResizablePMCArray"
+    push $P702, ""
+    .return ($P702)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "parameter"  :subid("172_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx707_tgt
+    .local int rx707_pos
+    .local int rx707_off
+    .local int rx707_eos
+    .local int rx707_rep
+    .local pmc rx707_cur
+    (rx707_cur, rx707_pos, rx707_tgt, $I10) = self."!cursor_start"()
+    rx707_cur."!cursor_caparray"("default_value", "typename")
+    .lex unicode:"$\x{a2}", rx707_cur
+    .local pmc match
+    .lex "$/", match
+    length rx707_eos, rx707_tgt
+    gt rx707_pos, rx707_eos, rx707_done
+    set rx707_off, 0
+    lt rx707_pos, 2, rx707_start
+    sub rx707_off, rx707_pos, 1
+    substr rx707_tgt, rx707_tgt, rx707_off
+  rx707_start:
+    eq $I10, 1, rx707_restart
+    rx707_cur."!cursor_debug"("START ", "parameter")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan710_done
+    goto rxscan710_scan
+  rxscan710_loop:
+    ($P10) = rx707_cur."from"()
+    inc $P10
+    set rx707_pos, $P10
+    ge rx707_pos, rx707_eos, rxscan710_done
+  rxscan710_scan:
+    set_addr $I10, rxscan710_loop
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  rxscan710_done:
+.annotate 'line', 326
+  # rx rxquantr711 ** 0..*
+    set_addr $I10, rxquantr711_done
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  rxquantr711_loop:
+  # rx subrule "typename" subtype=capture negate=
+    rx707_cur."!cursor_pos"(rx707_pos)
+    $P10 = rx707_cur."typename"()
+    unless $P10, rx707_fail
+    rx707_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("typename")
+    rx707_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx707_cur."!cursor_pos"(rx707_pos)
+    $P10 = rx707_cur."ws"()
+    unless $P10, rx707_fail
+    rx707_pos = $P10."pos"()
+    set_addr $I10, rxquantr711_done
+    (rx707_rep) = rx707_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr711_done
+    rx707_cur."!mark_push"(rx707_rep, rx707_pos, $I10)
+    goto rxquantr711_loop
+  rxquantr711_done:
+  alt712_0:
+.annotate 'line', 327
+    set_addr $I10, alt712_1
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+.annotate 'line', 328
+  # rx subcapture "quant"
+    set_addr $I10, rxcap_713_fail
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  # rx literal  "*"
+    add $I11, rx707_pos, 1
+    gt $I11, rx707_eos, rx707_fail
+    sub $I11, rx707_pos, rx707_off
+    substr $S10, rx707_tgt, $I11, 1
+    ne $S10, "*", rx707_fail
+    add rx707_pos, 1
+    set_addr $I10, rxcap_713_fail
+    ($I12, $I11) = rx707_cur."!mark_peek"($I10)
+    rx707_cur."!cursor_pos"($I11)
+    ($P10) = rx707_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx707_pos, "")
+    rx707_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("quant")
+    goto rxcap_713_done
+  rxcap_713_fail:
+    goto rx707_fail
+  rxcap_713_done:
+  # rx subrule "param_var" subtype=capture negate=
+    rx707_cur."!cursor_pos"(rx707_pos)
+    $P10 = rx707_cur."param_var"()
+    unless $P10, rx707_fail
+    rx707_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("param_var")
+    rx707_pos = $P10."pos"()
+    goto alt712_end
+  alt712_1:
+  alt714_0:
+.annotate 'line', 329
+    set_addr $I10, alt714_1
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  # rx subrule "param_var" subtype=capture negate=
+    rx707_cur."!cursor_pos"(rx707_pos)
+    $P10 = rx707_cur."param_var"()
+    unless $P10, rx707_fail
+    rx707_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("param_var")
+    rx707_pos = $P10."pos"()
+    goto alt714_end
+  alt714_1:
+  # rx subrule "named_param" subtype=capture negate=
+    rx707_cur."!cursor_pos"(rx707_pos)
+    $P10 = rx707_cur."named_param"()
+    unless $P10, rx707_fail
+    rx707_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("named_param")
+    rx707_pos = $P10."pos"()
+  alt714_end:
+  # rx subcapture "quant"
+    set_addr $I10, rxcap_716_fail
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  alt715_0:
+    set_addr $I10, alt715_1
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  # rx literal  "?"
+    add $I11, rx707_pos, 1
+    gt $I11, rx707_eos, rx707_fail
+    sub $I11, rx707_pos, rx707_off
+    substr $S10, rx707_tgt, $I11, 1
+    ne $S10, "?", rx707_fail
+    add rx707_pos, 1
+    goto alt715_end
+  alt715_1:
+    set_addr $I10, alt715_2
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  # rx literal  "!"
+    add $I11, rx707_pos, 1
+    gt $I11, rx707_eos, rx707_fail
+    sub $I11, rx707_pos, rx707_off
+    substr $S10, rx707_tgt, $I11, 1
+    ne $S10, "!", rx707_fail
+    add rx707_pos, 1
+    goto alt715_end
+  alt715_2:
+  alt715_end:
+    set_addr $I10, rxcap_716_fail
+    ($I12, $I11) = rx707_cur."!mark_peek"($I10)
+    rx707_cur."!cursor_pos"($I11)
+    ($P10) = rx707_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx707_pos, "")
+    rx707_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("quant")
+    goto rxcap_716_done
+  rxcap_716_fail:
+    goto rx707_fail
+  rxcap_716_done:
+  alt712_end:
+.annotate 'line', 331
+  # rx rxquantr717 ** 0..1
+    set_addr $I10, rxquantr717_done
+    rx707_cur."!mark_push"(0, rx707_pos, $I10)
+  rxquantr717_loop:
+  # rx subrule "default_value" subtype=capture negate=
+    rx707_cur."!cursor_pos"(rx707_pos)
+    $P10 = rx707_cur."default_value"()
+    unless $P10, rx707_fail
+    goto rxsubrule718_pass
+  rxsubrule718_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx707_fail
+  rxsubrule718_pass:
+    set_addr $I10, rxsubrule718_back
+    rx707_cur."!mark_push"(0, rx707_pos, $I10, $P10)
+    $P10."!cursor_names"("default_value")
+    rx707_pos = $P10."pos"()
+    set_addr $I10, rxquantr717_done
+    (rx707_rep) = rx707_cur."!mark_commit"($I10)
+  rxquantr717_done:
+.annotate 'line', 325
+  # rx pass
+    rx707_cur."!cursor_pass"(rx707_pos, "parameter")
+    rx707_cur."!cursor_debug"("PASS  ", "parameter", " at pos=", rx707_pos)
+    .return (rx707_cur)
+  rx707_restart:
+.annotate 'line', 4
+    rx707_cur."!cursor_debug"("NEXT ", "parameter")
+  rx707_fail:
+    (rx707_rep, rx707_pos, $I10, $P10) = rx707_cur."!mark_fail"(0)
+    lt rx707_pos, -1, rx707_done
+    eq rx707_pos, -1, rx707_fail
+    jump $I10
+  rx707_done:
+    rx707_cur."!cursor_fail"()
+    rx707_cur."!cursor_debug"("FAIL  ", "parameter")
+    .return (rx707_cur)
+    .return ()
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "!PREFIX__parameter"  :subid("173_1279529226.73787") :method
+.annotate 'line', 4
+    new $P709, "ResizablePMCArray"
+    push $P709, ""
+    .return ($P709)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "param_var"  :subid("174_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
     .local string rx720_tgt
     .local int rx720_pos
@@ -8440,8 +9148,8 @@
     .local int rx720_eos
     .local int rx720_rep
     .local pmc rx720_cur
-    (rx720_cur, rx720_pos, rx720_tgt) = self."!cursor_start"()
-    rx720_cur."!cursor_debug"("START ", "multi_declarator:sym<null>")
+    (rx720_cur, rx720_pos, rx720_tgt, $I10) = self."!cursor_start"()
+    rx720_cur."!cursor_caparray"("twigil")
     .lex unicode:"$\x{a2}", rx720_cur
     .local pmc match
     .lex "$/", match
@@ -8452,6 +9160,8 @@
     sub rx720_off, rx720_pos, 1
     substr rx720_tgt, rx720_tgt, rx720_off
   rx720_start:
+    eq $I10, 1, rx720_restart
+    rx720_cur."!cursor_debug"("START ", "param_var")
     $I10 = self.'from'()
     ne $I10, -1, rxscan724_done
     goto rxscan724_scan
@@ -8464,42 +9174,94 @@
     set_addr $I10, rxscan724_loop
     rx720_cur."!mark_push"(0, rx720_pos, $I10)
   rxscan724_done:
-.annotate 'line', 319
+.annotate 'line', 335
+  # rx subrule "sigil" subtype=capture negate=
     rx720_cur."!cursor_pos"(rx720_pos)
-    new $P725, "String"
-    assign $P725, ""
-    store_lex "$*MULTINESS", $P725
-.annotate 'line', 320
-  # rx subrule "declarator" subtype=capture negate=
+    $P10 = rx720_cur."sigil"()
+    unless $P10, rx720_fail
+    rx720_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("sigil")
+    rx720_pos = $P10."pos"()
+  # rx rxquantr725 ** 0..1
+    set_addr $I10, rxquantr725_done
+    rx720_cur."!mark_push"(0, rx720_pos, $I10)
+  rxquantr725_loop:
+  # rx subrule "twigil" subtype=capture negate=
+    rx720_cur."!cursor_pos"(rx720_pos)
+    $P10 = rx720_cur."twigil"()
+    unless $P10, rx720_fail
+    goto rxsubrule726_pass
+  rxsubrule726_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx720_fail
+  rxsubrule726_pass:
+    set_addr $I10, rxsubrule726_back
+    rx720_cur."!mark_push"(0, rx720_pos, $I10, $P10)
+    $P10."!cursor_names"("twigil")
+    rx720_pos = $P10."pos"()
+    set_addr $I10, rxquantr725_done
+    (rx720_rep) = rx720_cur."!mark_commit"($I10)
+  rxquantr725_done:
+  alt727_0:
+.annotate 'line', 336
+    set_addr $I10, alt727_1
+    rx720_cur."!mark_push"(0, rx720_pos, $I10)
+  # rx subrule "ident" subtype=capture negate=
     rx720_cur."!cursor_pos"(rx720_pos)
-    $P10 = rx720_cur."declarator"()
+    $P10 = rx720_cur."ident"()
     unless $P10, rx720_fail
     rx720_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("declarator")
+    $P10."!cursor_names"("name")
     rx720_pos = $P10."pos"()
-.annotate 'line', 318
+    goto alt727_end
+  alt727_1:
+  # rx subcapture "name"
+    set_addr $I10, rxcap_728_fail
+    rx720_cur."!mark_push"(0, rx720_pos, $I10)
+  # rx enumcharlist negate=0 
+    ge rx720_pos, rx720_eos, rx720_fail
+    sub $I10, rx720_pos, rx720_off
+    substr $S10, rx720_tgt, $I10, 1
+    index $I11, "/!", $S10
+    lt $I11, 0, rx720_fail
+    inc rx720_pos
+    set_addr $I10, rxcap_728_fail
+    ($I12, $I11) = rx720_cur."!mark_peek"($I10)
+    rx720_cur."!cursor_pos"($I11)
+    ($P10) = rx720_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx720_pos, "")
+    rx720_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("name")
+    goto rxcap_728_done
+  rxcap_728_fail:
+    goto rx720_fail
+  rxcap_728_done:
+  alt727_end:
+.annotate 'line', 334
   # rx pass
-    rx720_cur."!cursor_pass"(rx720_pos, "multi_declarator:sym<null>")
-    rx720_cur."!cursor_debug"("PASS  ", "multi_declarator:sym<null>", " at pos=", rx720_pos)
+    rx720_cur."!cursor_pass"(rx720_pos, "param_var")
+    rx720_cur."!cursor_debug"("PASS  ", "param_var", " at pos=", rx720_pos)
     .return (rx720_cur)
-  rx720_fail:
+  rx720_restart:
 .annotate 'line', 4
+    rx720_cur."!cursor_debug"("NEXT ", "param_var")
+  rx720_fail:
     (rx720_rep, rx720_pos, $I10, $P10) = rx720_cur."!mark_fail"(0)
     lt rx720_pos, -1, rx720_done
     eq rx720_pos, -1, rx720_fail
     jump $I10
   rx720_done:
     rx720_cur."!cursor_fail"()
-    rx720_cur."!cursor_debug"("FAIL  ", "multi_declarator:sym<null>")
+    rx720_cur."!cursor_debug"("FAIL  ", "param_var")
     .return (rx720_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__multi_declarator:sym<null>"  :subid("169_1278500537.15927") :method
+.sub "!PREFIX__param_var"  :subid("175_1279529226.73787") :method
 .annotate 'line', 4
-    $P722 = self."!PREFIX__!subrule"("declarator", "")
+    $P722 = self."!PREFIX__!subrule"("sigil", "")
     new $P723, "ResizablePMCArray"
     push $P723, $P722
     .return ($P723)
@@ -8507,107 +9269,87 @@
 
 
 .namespace ["NQP";"Grammar"]
-.sub "signature"  :subid("170_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx727_tgt
-    .local int rx727_pos
-    .local int rx727_off
-    .local int rx727_eos
-    .local int rx727_rep
-    .local pmc rx727_cur
-    (rx727_cur, rx727_pos, rx727_tgt) = self."!cursor_start"()
-    rx727_cur."!cursor_debug"("START ", "signature")
-    rx727_cur."!cursor_caparray"("parameter")
-    .lex unicode:"$\x{a2}", rx727_cur
-    .local pmc match
-    .lex "$/", match
-    length rx727_eos, rx727_tgt
-    gt rx727_pos, rx727_eos, rx727_done
-    set rx727_off, 0
-    lt rx727_pos, 2, rx727_start
-    sub rx727_off, rx727_pos, 1
-    substr rx727_tgt, rx727_tgt, rx727_off
-  rx727_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan730_done
-    goto rxscan730_scan
-  rxscan730_loop:
-    ($P10) = rx727_cur."from"()
-    inc $P10
-    set rx727_pos, $P10
-    ge rx727_pos, rx727_eos, rxscan730_done
-  rxscan730_scan:
-    set_addr $I10, rxscan730_loop
-    rx727_cur."!mark_push"(0, rx727_pos, $I10)
-  rxscan730_done:
-.annotate 'line', 323
-  # rx rxquantr731 ** 0..1
-    set_addr $I734, rxquantr731_done
-    rx727_cur."!mark_push"(0, rx727_pos, $I734)
-  rxquantr731_loop:
-  # rx rxquantr732 ** 1..*
-    set_addr $I733, rxquantr732_done
-    rx727_cur."!mark_push"(0, -1, $I733)
-  rxquantr732_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx727_cur."!cursor_pos"(rx727_pos)
-    $P10 = rx727_cur."ws"()
-    unless $P10, rx727_fail
-    rx727_pos = $P10."pos"()
-  # rx subrule "parameter" subtype=capture negate=
-    rx727_cur."!cursor_pos"(rx727_pos)
-    $P10 = rx727_cur."parameter"()
-    unless $P10, rx727_fail
-    rx727_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("parameter")
-    rx727_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx727_cur."!cursor_pos"(rx727_pos)
-    $P10 = rx727_cur."ws"()
-    unless $P10, rx727_fail
-    rx727_pos = $P10."pos"()
-    (rx727_rep) = rx727_cur."!mark_commit"($I733)
-    rx727_cur."!mark_push"(rx727_rep, rx727_pos, $I733)
-  # rx literal  ","
-    add $I11, rx727_pos, 1
-    gt $I11, rx727_eos, rx727_fail
-    sub $I11, rx727_pos, rx727_off
-    substr $S10, rx727_tgt, $I11, 1
-    ne $S10, ",", rx727_fail
-    add rx727_pos, 1
-    goto rxquantr732_loop
-  rxquantr732_done:
-    (rx727_rep) = rx727_cur."!mark_commit"($I734)
-  rxquantr731_done:
-  # rx pass
-    rx727_cur."!cursor_pass"(rx727_pos, "signature")
-    rx727_cur."!cursor_debug"("PASS  ", "signature", " at pos=", rx727_pos)
-    .return (rx727_cur)
-  rx727_fail:
+.sub "named_param"  :subid("176_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    (rx727_rep, rx727_pos, $I10, $P10) = rx727_cur."!mark_fail"(0)
-    lt rx727_pos, -1, rx727_done
-    eq rx727_pos, -1, rx727_fail
+    .local string rx730_tgt
+    .local int rx730_pos
+    .local int rx730_off
+    .local int rx730_eos
+    .local int rx730_rep
+    .local pmc rx730_cur
+    (rx730_cur, rx730_pos, rx730_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx730_cur
+    .local pmc match
+    .lex "$/", match
+    length rx730_eos, rx730_tgt
+    gt rx730_pos, rx730_eos, rx730_done
+    set rx730_off, 0
+    lt rx730_pos, 2, rx730_start
+    sub rx730_off, rx730_pos, 1
+    substr rx730_tgt, rx730_tgt, rx730_off
+  rx730_start:
+    eq $I10, 1, rx730_restart
+    rx730_cur."!cursor_debug"("START ", "named_param")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan734_done
+    goto rxscan734_scan
+  rxscan734_loop:
+    ($P10) = rx730_cur."from"()
+    inc $P10
+    set rx730_pos, $P10
+    ge rx730_pos, rx730_eos, rxscan734_done
+  rxscan734_scan:
+    set_addr $I10, rxscan734_loop
+    rx730_cur."!mark_push"(0, rx730_pos, $I10)
+  rxscan734_done:
+.annotate 'line', 340
+  # rx literal  ":"
+    add $I11, rx730_pos, 1
+    gt $I11, rx730_eos, rx730_fail
+    sub $I11, rx730_pos, rx730_off
+    substr $S10, rx730_tgt, $I11, 1
+    ne $S10, ":", rx730_fail
+    add rx730_pos, 1
+  # rx subrule "param_var" subtype=capture negate=
+    rx730_cur."!cursor_pos"(rx730_pos)
+    $P10 = rx730_cur."param_var"()
+    unless $P10, rx730_fail
+    rx730_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("param_var")
+    rx730_pos = $P10."pos"()
+.annotate 'line', 339
+  # rx pass
+    rx730_cur."!cursor_pass"(rx730_pos, "named_param")
+    rx730_cur."!cursor_debug"("PASS  ", "named_param", " at pos=", rx730_pos)
+    .return (rx730_cur)
+  rx730_restart:
+.annotate 'line', 4
+    rx730_cur."!cursor_debug"("NEXT ", "named_param")
+  rx730_fail:
+    (rx730_rep, rx730_pos, $I10, $P10) = rx730_cur."!mark_fail"(0)
+    lt rx730_pos, -1, rx730_done
+    eq rx730_pos, -1, rx730_fail
     jump $I10
-  rx727_done:
-    rx727_cur."!cursor_fail"()
-    rx727_cur."!cursor_debug"("FAIL  ", "signature")
-    .return (rx727_cur)
+  rx730_done:
+    rx730_cur."!cursor_fail"()
+    rx730_cur."!cursor_debug"("FAIL  ", "named_param")
+    .return (rx730_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__signature"  :subid("171_1278500537.15927") :method
+.sub "!PREFIX__named_param"  :subid("177_1279529226.73787") :method
 .annotate 'line', 4
-    new $P729, "ResizablePMCArray"
-    push $P729, ""
-    .return ($P729)
+    $P732 = self."!PREFIX__!subrule"("param_var", ":")
+    new $P733, "ResizablePMCArray"
+    push $P733, $P732
+    .return ($P733)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "parameter"  :subid("172_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "default_value"  :subid("178_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
     .local string rx736_tgt
     .local int rx736_pos
@@ -8615,9 +9357,7 @@
     .local int rx736_eos
     .local int rx736_rep
     .local pmc rx736_cur
-    (rx736_cur, rx736_pos, rx736_tgt) = self."!cursor_start"()
-    rx736_cur."!cursor_debug"("START ", "parameter")
-    rx736_cur."!cursor_caparray"("default_value", "typename")
+    (rx736_cur, rx736_pos, rx736_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx736_cur
     .local pmc match
     .lex "$/", match
@@ -8628,9196 +9368,9134 @@
     sub rx736_off, rx736_pos, 1
     substr rx736_tgt, rx736_tgt, rx736_off
   rx736_start:
+    eq $I10, 1, rx736_restart
+    rx736_cur."!cursor_debug"("START ", "default_value")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan739_done
-    goto rxscan739_scan
-  rxscan739_loop:
+    ne $I10, -1, rxscan740_done
+    goto rxscan740_scan
+  rxscan740_loop:
     ($P10) = rx736_cur."from"()
     inc $P10
     set rx736_pos, $P10
-    ge rx736_pos, rx736_eos, rxscan739_done
-  rxscan739_scan:
-    set_addr $I10, rxscan739_loop
+    ge rx736_pos, rx736_eos, rxscan740_done
+  rxscan740_scan:
+    set_addr $I10, rxscan740_loop
     rx736_cur."!mark_push"(0, rx736_pos, $I10)
-  rxscan739_done:
-.annotate 'line', 326
-  # rx rxquantr740 ** 0..*
-    set_addr $I741, rxquantr740_done
-    rx736_cur."!mark_push"(0, rx736_pos, $I741)
-  rxquantr740_loop:
-  # rx subrule "typename" subtype=capture negate=
-    rx736_cur."!cursor_pos"(rx736_pos)
-    $P10 = rx736_cur."typename"()
-    unless $P10, rx736_fail
-    rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("typename")
-    rx736_pos = $P10."pos"()
+  rxscan740_done:
+.annotate 'line', 343
   # rx subrule "ws" subtype=method negate=
     rx736_cur."!cursor_pos"(rx736_pos)
     $P10 = rx736_cur."ws"()
     unless $P10, rx736_fail
     rx736_pos = $P10."pos"()
-    (rx736_rep) = rx736_cur."!mark_commit"($I741)
-    rx736_cur."!mark_push"(rx736_rep, rx736_pos, $I741)
-    goto rxquantr740_loop
-  rxquantr740_done:
-  alt742_0:
-.annotate 'line', 327
-    set_addr $I10, alt742_1
-    rx736_cur."!mark_push"(0, rx736_pos, $I10)
-.annotate 'line', 328
-  # rx subcapture "quant"
-    set_addr $I10, rxcap_743_fail
-    rx736_cur."!mark_push"(0, rx736_pos, $I10)
-  # rx literal  "*"
+  # rx literal  "="
     add $I11, rx736_pos, 1
     gt $I11, rx736_eos, rx736_fail
     sub $I11, rx736_pos, rx736_off
     substr $S10, rx736_tgt, $I11, 1
-    ne $S10, "*", rx736_fail
+    ne $S10, "=", rx736_fail
     add rx736_pos, 1
-    set_addr $I10, rxcap_743_fail
-    ($I12, $I11) = rx736_cur."!mark_peek"($I10)
-    rx736_cur."!cursor_pos"($I11)
-    ($P10) = rx736_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx736_pos, "")
-    rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("quant")
-    goto rxcap_743_done
-  rxcap_743_fail:
-    goto rx736_fail
-  rxcap_743_done:
-  # rx subrule "param_var" subtype=capture negate=
-    rx736_cur."!cursor_pos"(rx736_pos)
-    $P10 = rx736_cur."param_var"()
-    unless $P10, rx736_fail
-    rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("param_var")
-    rx736_pos = $P10."pos"()
-    goto alt742_end
-  alt742_1:
-  alt744_0:
-.annotate 'line', 329
-    set_addr $I10, alt744_1
-    rx736_cur."!mark_push"(0, rx736_pos, $I10)
-  # rx subrule "param_var" subtype=capture negate=
+  # rx subrule "ws" subtype=method negate=
     rx736_cur."!cursor_pos"(rx736_pos)
-    $P10 = rx736_cur."param_var"()
+    $P10 = rx736_cur."ws"()
     unless $P10, rx736_fail
-    rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("param_var")
     rx736_pos = $P10."pos"()
-    goto alt744_end
-  alt744_1:
-  # rx subrule "named_param" subtype=capture negate=
+  # rx subrule "EXPR" subtype=capture negate=
     rx736_cur."!cursor_pos"(rx736_pos)
-    $P10 = rx736_cur."named_param"()
+    $P10 = rx736_cur."EXPR"("i=")
     unless $P10, rx736_fail
     rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("named_param")
+    $P10."!cursor_names"("EXPR")
     rx736_pos = $P10."pos"()
-  alt744_end:
-  # rx subcapture "quant"
-    set_addr $I10, rxcap_746_fail
-    rx736_cur."!mark_push"(0, rx736_pos, $I10)
-  alt745_0:
-    set_addr $I10, alt745_1
-    rx736_cur."!mark_push"(0, rx736_pos, $I10)
-  # rx literal  "?"
-    add $I11, rx736_pos, 1
-    gt $I11, rx736_eos, rx736_fail
-    sub $I11, rx736_pos, rx736_off
-    substr $S10, rx736_tgt, $I11, 1
-    ne $S10, "?", rx736_fail
-    add rx736_pos, 1
-    goto alt745_end
-  alt745_1:
-    set_addr $I10, alt745_2
-    rx736_cur."!mark_push"(0, rx736_pos, $I10)
-  # rx literal  "!"
-    add $I11, rx736_pos, 1
-    gt $I11, rx736_eos, rx736_fail
-    sub $I11, rx736_pos, rx736_off
-    substr $S10, rx736_tgt, $I11, 1
-    ne $S10, "!", rx736_fail
-    add rx736_pos, 1
-    goto alt745_end
-  alt745_2:
-  alt745_end:
-    set_addr $I10, rxcap_746_fail
-    ($I12, $I11) = rx736_cur."!mark_peek"($I10)
-    rx736_cur."!cursor_pos"($I11)
-    ($P10) = rx736_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx736_pos, "")
-    rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("quant")
-    goto rxcap_746_done
-  rxcap_746_fail:
-    goto rx736_fail
-  rxcap_746_done:
-  alt742_end:
-.annotate 'line', 331
-  # rx rxquantr747 ** 0..1
-    set_addr $I748, rxquantr747_done
-    rx736_cur."!mark_push"(0, rx736_pos, $I748)
-  rxquantr747_loop:
-  # rx subrule "default_value" subtype=capture negate=
+  # rx subrule "ws" subtype=method negate=
     rx736_cur."!cursor_pos"(rx736_pos)
-    $P10 = rx736_cur."default_value"()
+    $P10 = rx736_cur."ws"()
     unless $P10, rx736_fail
-    rx736_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("default_value")
     rx736_pos = $P10."pos"()
-    (rx736_rep) = rx736_cur."!mark_commit"($I748)
-  rxquantr747_done:
-.annotate 'line', 325
   # rx pass
-    rx736_cur."!cursor_pass"(rx736_pos, "parameter")
-    rx736_cur."!cursor_debug"("PASS  ", "parameter", " at pos=", rx736_pos)
+    rx736_cur."!cursor_pass"(rx736_pos, "default_value")
+    rx736_cur."!cursor_debug"("PASS  ", "default_value", " at pos=", rx736_pos)
     .return (rx736_cur)
-  rx736_fail:
+  rx736_restart:
 .annotate 'line', 4
+    rx736_cur."!cursor_debug"("NEXT ", "default_value")
+  rx736_fail:
     (rx736_rep, rx736_pos, $I10, $P10) = rx736_cur."!mark_fail"(0)
     lt rx736_pos, -1, rx736_done
     eq rx736_pos, -1, rx736_fail
     jump $I10
   rx736_done:
     rx736_cur."!cursor_fail"()
-    rx736_cur."!cursor_debug"("FAIL  ", "parameter")
+    rx736_cur."!cursor_debug"("FAIL  ", "default_value")
     .return (rx736_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__parameter"  :subid("173_1278500537.15927") :method
-.annotate 'line', 4
-    new $P738, "ResizablePMCArray"
-    push $P738, ""
-    .return ($P738)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "param_var"  :subid("174_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx750_tgt
-    .local int rx750_pos
-    .local int rx750_off
-    .local int rx750_eos
-    .local int rx750_rep
-    .local pmc rx750_cur
-    (rx750_cur, rx750_pos, rx750_tgt) = self."!cursor_start"()
-    rx750_cur."!cursor_debug"("START ", "param_var")
-    rx750_cur."!cursor_caparray"("twigil")
-    .lex unicode:"$\x{a2}", rx750_cur
-    .local pmc match
-    .lex "$/", match
-    length rx750_eos, rx750_tgt
-    gt rx750_pos, rx750_eos, rx750_done
-    set rx750_off, 0
-    lt rx750_pos, 2, rx750_start
-    sub rx750_off, rx750_pos, 1
-    substr rx750_tgt, rx750_tgt, rx750_off
-  rx750_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan754_done
-    goto rxscan754_scan
-  rxscan754_loop:
-    ($P10) = rx750_cur."from"()
-    inc $P10
-    set rx750_pos, $P10
-    ge rx750_pos, rx750_eos, rxscan754_done
-  rxscan754_scan:
-    set_addr $I10, rxscan754_loop
-    rx750_cur."!mark_push"(0, rx750_pos, $I10)
-  rxscan754_done:
-.annotate 'line', 335
-  # rx subrule "sigil" subtype=capture negate=
-    rx750_cur."!cursor_pos"(rx750_pos)
-    $P10 = rx750_cur."sigil"()
-    unless $P10, rx750_fail
-    rx750_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("sigil")
-    rx750_pos = $P10."pos"()
-  # rx rxquantr755 ** 0..1
-    set_addr $I756, rxquantr755_done
-    rx750_cur."!mark_push"(0, rx750_pos, $I756)
-  rxquantr755_loop:
-  # rx subrule "twigil" subtype=capture negate=
-    rx750_cur."!cursor_pos"(rx750_pos)
-    $P10 = rx750_cur."twigil"()
-    unless $P10, rx750_fail
-    rx750_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("twigil")
-    rx750_pos = $P10."pos"()
-    (rx750_rep) = rx750_cur."!mark_commit"($I756)
-  rxquantr755_done:
-  alt757_0:
-.annotate 'line', 336
-    set_addr $I10, alt757_1
-    rx750_cur."!mark_push"(0, rx750_pos, $I10)
-  # rx subrule "ident" subtype=capture negate=
-    rx750_cur."!cursor_pos"(rx750_pos)
-    $P10 = rx750_cur."ident"()
-    unless $P10, rx750_fail
-    rx750_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("name")
-    rx750_pos = $P10."pos"()
-    goto alt757_end
-  alt757_1:
-  # rx subcapture "name"
-    set_addr $I10, rxcap_758_fail
-    rx750_cur."!mark_push"(0, rx750_pos, $I10)
-  # rx enumcharlist negate=0 
-    ge rx750_pos, rx750_eos, rx750_fail
-    sub $I10, rx750_pos, rx750_off
-    substr $S10, rx750_tgt, $I10, 1
-    index $I11, "/!", $S10
-    lt $I11, 0, rx750_fail
-    inc rx750_pos
-    set_addr $I10, rxcap_758_fail
-    ($I12, $I11) = rx750_cur."!mark_peek"($I10)
-    rx750_cur."!cursor_pos"($I11)
-    ($P10) = rx750_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx750_pos, "")
-    rx750_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("name")
-    goto rxcap_758_done
-  rxcap_758_fail:
-    goto rx750_fail
-  rxcap_758_done:
-  alt757_end:
-.annotate 'line', 334
-  # rx pass
-    rx750_cur."!cursor_pass"(rx750_pos, "param_var")
-    rx750_cur."!cursor_debug"("PASS  ", "param_var", " at pos=", rx750_pos)
-    .return (rx750_cur)
-  rx750_fail:
-.annotate 'line', 4
-    (rx750_rep, rx750_pos, $I10, $P10) = rx750_cur."!mark_fail"(0)
-    lt rx750_pos, -1, rx750_done
-    eq rx750_pos, -1, rx750_fail
-    jump $I10
-  rx750_done:
-    rx750_cur."!cursor_fail"()
-    rx750_cur."!cursor_debug"("FAIL  ", "param_var")
-    .return (rx750_cur)
-    .return ()
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "!PREFIX__param_var"  :subid("175_1278500537.15927") :method
-.annotate 'line', 4
-    $P752 = self."!PREFIX__!subrule"("sigil", "")
-    new $P753, "ResizablePMCArray"
-    push $P753, $P752
-    .return ($P753)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "named_param"  :subid("176_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx760_tgt
-    .local int rx760_pos
-    .local int rx760_off
-    .local int rx760_eos
-    .local int rx760_rep
-    .local pmc rx760_cur
-    (rx760_cur, rx760_pos, rx760_tgt) = self."!cursor_start"()
-    rx760_cur."!cursor_debug"("START ", "named_param")
-    .lex unicode:"$\x{a2}", rx760_cur
-    .local pmc match
-    .lex "$/", match
-    length rx760_eos, rx760_tgt
-    gt rx760_pos, rx760_eos, rx760_done
-    set rx760_off, 0
-    lt rx760_pos, 2, rx760_start
-    sub rx760_off, rx760_pos, 1
-    substr rx760_tgt, rx760_tgt, rx760_off
-  rx760_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan764_done
-    goto rxscan764_scan
-  rxscan764_loop:
-    ($P10) = rx760_cur."from"()
-    inc $P10
-    set rx760_pos, $P10
-    ge rx760_pos, rx760_eos, rxscan764_done
-  rxscan764_scan:
-    set_addr $I10, rxscan764_loop
-    rx760_cur."!mark_push"(0, rx760_pos, $I10)
-  rxscan764_done:
-.annotate 'line', 340
-  # rx literal  ":"
-    add $I11, rx760_pos, 1
-    gt $I11, rx760_eos, rx760_fail
-    sub $I11, rx760_pos, rx760_off
-    substr $S10, rx760_tgt, $I11, 1
-    ne $S10, ":", rx760_fail
-    add rx760_pos, 1
-  # rx subrule "param_var" subtype=capture negate=
-    rx760_cur."!cursor_pos"(rx760_pos)
-    $P10 = rx760_cur."param_var"()
-    unless $P10, rx760_fail
-    rx760_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("param_var")
-    rx760_pos = $P10."pos"()
-.annotate 'line', 339
-  # rx pass
-    rx760_cur."!cursor_pass"(rx760_pos, "named_param")
-    rx760_cur."!cursor_debug"("PASS  ", "named_param", " at pos=", rx760_pos)
-    .return (rx760_cur)
-  rx760_fail:
-.annotate 'line', 4
-    (rx760_rep, rx760_pos, $I10, $P10) = rx760_cur."!mark_fail"(0)
-    lt rx760_pos, -1, rx760_done
-    eq rx760_pos, -1, rx760_fail
-    jump $I10
-  rx760_done:
-    rx760_cur."!cursor_fail"()
-    rx760_cur."!cursor_debug"("FAIL  ", "named_param")
-    .return (rx760_cur)
-    .return ()
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "!PREFIX__named_param"  :subid("177_1278500537.15927") :method
-.annotate 'line', 4
-    $P762 = self."!PREFIX__!subrule"("param_var", ":")
-    new $P763, "ResizablePMCArray"
-    push $P763, $P762
-    .return ($P763)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "default_value"  :subid("178_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx766_tgt
-    .local int rx766_pos
-    .local int rx766_off
-    .local int rx766_eos
-    .local int rx766_rep
-    .local pmc rx766_cur
-    (rx766_cur, rx766_pos, rx766_tgt) = self."!cursor_start"()
-    rx766_cur."!cursor_debug"("START ", "default_value")
-    .lex unicode:"$\x{a2}", rx766_cur
-    .local pmc match
-    .lex "$/", match
-    length rx766_eos, rx766_tgt
-    gt rx766_pos, rx766_eos, rx766_done
-    set rx766_off, 0
-    lt rx766_pos, 2, rx766_start
-    sub rx766_off, rx766_pos, 1
-    substr rx766_tgt, rx766_tgt, rx766_off
-  rx766_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan770_done
-    goto rxscan770_scan
-  rxscan770_loop:
-    ($P10) = rx766_cur."from"()
-    inc $P10
-    set rx766_pos, $P10
-    ge rx766_pos, rx766_eos, rxscan770_done
-  rxscan770_scan:
-    set_addr $I10, rxscan770_loop
-    rx766_cur."!mark_push"(0, rx766_pos, $I10)
-  rxscan770_done:
-.annotate 'line', 343
-  # rx subrule "ws" subtype=method negate=
-    rx766_cur."!cursor_pos"(rx766_pos)
-    $P10 = rx766_cur."ws"()
-    unless $P10, rx766_fail
-    rx766_pos = $P10."pos"()
-  # rx literal  "="
-    add $I11, rx766_pos, 1
-    gt $I11, rx766_eos, rx766_fail
-    sub $I11, rx766_pos, rx766_off
-    substr $S10, rx766_tgt, $I11, 1
-    ne $S10, "=", rx766_fail
-    add rx766_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx766_cur."!cursor_pos"(rx766_pos)
-    $P10 = rx766_cur."ws"()
-    unless $P10, rx766_fail
-    rx766_pos = $P10."pos"()
-  # rx subrule "EXPR" subtype=capture negate=
-    rx766_cur."!cursor_pos"(rx766_pos)
-    $P10 = rx766_cur."EXPR"("i=")
-    unless $P10, rx766_fail
-    rx766_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("EXPR")
-    rx766_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx766_cur."!cursor_pos"(rx766_pos)
-    $P10 = rx766_cur."ws"()
-    unless $P10, rx766_fail
-    rx766_pos = $P10."pos"()
-  # rx pass
-    rx766_cur."!cursor_pass"(rx766_pos, "default_value")
-    rx766_cur."!cursor_debug"("PASS  ", "default_value", " at pos=", rx766_pos)
-    .return (rx766_cur)
-  rx766_fail:
-.annotate 'line', 4
-    (rx766_rep, rx766_pos, $I10, $P10) = rx766_cur."!mark_fail"(0)
-    lt rx766_pos, -1, rx766_done
-    eq rx766_pos, -1, rx766_fail
-    jump $I10
-  rx766_done:
-    rx766_cur."!cursor_fail"()
-    rx766_cur."!cursor_debug"("FAIL  ", "default_value")
-    .return (rx766_cur)
-    .return ()
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "!PREFIX__default_value"  :subid("179_1278500537.15927") :method
+.sub "!PREFIX__default_value"  :subid("179_1279529226.73787") :method
 .annotate 'line', 4
-    $P768 = self."!PREFIX__!subrule"("ws", "")
-    new $P769, "ResizablePMCArray"
-    push $P769, $P768
-    .return ($P769)
+    $P738 = self."!PREFIX__!subrule"("ws", "")
+    new $P739, "ResizablePMCArray"
+    push $P739, $P738
+    .return ($P739)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "regex_declarator"  :subid("180_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "regex_declarator"  :subid("180_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx775_tgt
-    .local int rx775_pos
-    .local int rx775_off
-    .local int rx775_eos
-    .local int rx775_rep
-    .local pmc rx775_cur
-    (rx775_cur, rx775_pos, rx775_tgt) = self."!cursor_start"()
-    rx775_cur."!cursor_debug"("START ", "regex_declarator")
-    rx775_cur."!cursor_caparray"("signature")
-    .lex unicode:"$\x{a2}", rx775_cur
-    .local pmc match
-    .lex "$/", match
-    length rx775_eos, rx775_tgt
-    gt rx775_pos, rx775_eos, rx775_done
-    set rx775_off, 0
-    lt rx775_pos, 2, rx775_start
-    sub rx775_off, rx775_pos, 1
-    substr rx775_tgt, rx775_tgt, rx775_off
-  rx775_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan779_done
-    goto rxscan779_scan
-  rxscan779_loop:
-    ($P10) = rx775_cur."from"()
-    inc $P10
-    set rx775_pos, $P10
-    ge rx775_pos, rx775_eos, rxscan779_done
-  rxscan779_scan:
-    set_addr $I10, rxscan779_loop
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
-  rxscan779_done:
+    .local string rx745_tgt
+    .local int rx745_pos
+    .local int rx745_off
+    .local int rx745_eos
+    .local int rx745_rep
+    .local pmc rx745_cur
+    (rx745_cur, rx745_pos, rx745_tgt, $I10) = self."!cursor_start"()
+    rx745_cur."!cursor_caparray"("signature")
+    .lex unicode:"$\x{a2}", rx745_cur
+    .local pmc match
+    .lex "$/", match
+    length rx745_eos, rx745_tgt
+    gt rx745_pos, rx745_eos, rx745_done
+    set rx745_off, 0
+    lt rx745_pos, 2, rx745_start
+    sub rx745_off, rx745_pos, 1
+    substr rx745_tgt, rx745_tgt, rx745_off
+  rx745_start:
+    eq $I10, 1, rx745_restart
+    rx745_cur."!cursor_debug"("START ", "regex_declarator")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan749_done
+    goto rxscan749_scan
+  rxscan749_loop:
+    ($P10) = rx745_cur."from"()
+    inc $P10
+    set rx745_pos, $P10
+    ge rx745_pos, rx745_eos, rxscan749_done
+  rxscan749_scan:
+    set_addr $I10, rxscan749_loop
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
+  rxscan749_done:
 .annotate 'line', 345
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  alt781_0:
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  alt751_0:
 .annotate 'line', 346
-    set_addr $I10, alt781_1
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    set_addr $I10, alt751_1
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
 .annotate 'line', 347
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx subcapture "proto"
-    set_addr $I10, rxcap_783_fail
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    set_addr $I10, rxcap_753_fail
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
   # rx literal  "proto"
-    add $I11, rx775_pos, 5
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 5
-    ne $S10, "proto", rx775_fail
-    add rx775_pos, 5
-    set_addr $I10, rxcap_783_fail
-    ($I12, $I11) = rx775_cur."!mark_peek"($I10)
-    rx775_cur."!cursor_pos"($I11)
-    ($P10) = rx775_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx775_pos, "")
-    rx775_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx745_pos, 5
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 5
+    ne $S10, "proto", rx745_fail
+    add rx745_pos, 5
+    set_addr $I10, rxcap_753_fail
+    ($I12, $I11) = rx745_cur."!mark_peek"($I10)
+    rx745_cur."!cursor_pos"($I11)
+    ($P10) = rx745_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx745_pos, "")
+    rx745_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("proto")
-    goto rxcap_783_done
-  rxcap_783_fail:
-    goto rx775_fail
-  rxcap_783_done:
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  alt785_0:
-    set_addr $I10, alt785_1
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    goto rxcap_753_done
+  rxcap_753_fail:
+    goto rx745_fail
+  rxcap_753_done:
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  alt755_0:
+    set_addr $I10, alt755_1
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
   # rx literal  "regex"
-    add $I11, rx775_pos, 5
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 5
-    ne $S10, "regex", rx775_fail
-    add rx775_pos, 5
-    goto alt785_end
-  alt785_1:
-    set_addr $I10, alt785_2
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    add $I11, rx745_pos, 5
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 5
+    ne $S10, "regex", rx745_fail
+    add rx745_pos, 5
+    goto alt755_end
+  alt755_1:
+    set_addr $I10, alt755_2
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
   # rx literal  "token"
-    add $I11, rx775_pos, 5
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 5
-    ne $S10, "token", rx775_fail
-    add rx775_pos, 5
-    goto alt785_end
-  alt785_2:
+    add $I11, rx745_pos, 5
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 5
+    ne $S10, "token", rx745_fail
+    add rx745_pos, 5
+    goto alt755_end
+  alt755_2:
   # rx literal  "rule"
-    add $I11, rx775_pos, 4
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 4
-    ne $S10, "rule", rx775_fail
-    add rx775_pos, 4
-  alt785_end:
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    add $I11, rx745_pos, 4
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 4
+    ne $S10, "rule", rx745_fail
+    add rx745_pos, 4
+  alt755_end:
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 348
   # rx subrule "deflongname" subtype=capture negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."deflongname"()
-    unless $P10, rx775_fail
-    rx775_cur."!mark_push"(0, -1, 0, $P10)
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."deflongname"()
+    unless $P10, rx745_fail
+    rx745_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("deflongname")
-    rx775_pos = $P10."pos"()
+    rx745_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  alt788_0:
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  alt758_0:
 .annotate 'line', 349
-    set_addr $I10, alt788_1
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    set_addr $I10, alt758_1
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
 .annotate 'line', 350
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx literal  "{"
-    add $I11, rx775_pos, 1
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 1
-    ne $S10, "{", rx775_fail
-    add rx775_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    add $I11, rx745_pos, 1
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 1
+    ne $S10, "{", rx745_fail
+    add rx745_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx literal  "<...>"
-    add $I11, rx775_pos, 5
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 5
-    ne $S10, "<...>", rx775_fail
-    add rx775_pos, 5
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    add $I11, rx745_pos, 5
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 5
+    ne $S10, "<...>", rx745_fail
+    add rx745_pos, 5
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx literal  "}"
-    add $I11, rx775_pos, 1
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 1
-    ne $S10, "}", rx775_fail
-    add rx775_pos, 1
+    add $I11, rx745_pos, 1
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 1
+    ne $S10, "}", rx745_fail
+    add rx745_pos, 1
   # rx subrule "ENDSTMT" subtype=zerowidth negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ENDSTMT"()
-    unless $P10, rx775_fail
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-    goto alt788_end
-  alt788_1:
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ENDSTMT"()
+    unless $P10, rx745_fail
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+    goto alt758_end
+  alt758_1:
 .annotate 'line', 351
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx subrule "panic" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."panic"("Proto regex body must be <...>")
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  alt788_end:
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."panic"("Proto regex body must be <...>")
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  alt758_end:
 .annotate 'line', 352
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 347
-    goto alt781_end
-  alt781_1:
+    goto alt751_end
+  alt751_1:
 .annotate 'line', 353
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx subcapture "sym"
-    set_addr $I10, rxcap_798_fail
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
-  alt797_0:
-    set_addr $I10, alt797_1
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    set_addr $I10, rxcap_768_fail
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
+  alt767_0:
+    set_addr $I10, alt767_1
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
   # rx literal  "regex"
-    add $I11, rx775_pos, 5
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 5
-    ne $S10, "regex", rx775_fail
-    add rx775_pos, 5
-    goto alt797_end
-  alt797_1:
-    set_addr $I10, alt797_2
-    rx775_cur."!mark_push"(0, rx775_pos, $I10)
+    add $I11, rx745_pos, 5
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 5
+    ne $S10, "regex", rx745_fail
+    add rx745_pos, 5
+    goto alt767_end
+  alt767_1:
+    set_addr $I10, alt767_2
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
   # rx literal  "token"
-    add $I11, rx775_pos, 5
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 5
-    ne $S10, "token", rx775_fail
-    add rx775_pos, 5
-    goto alt797_end
-  alt797_2:
+    add $I11, rx745_pos, 5
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 5
+    ne $S10, "token", rx745_fail
+    add rx745_pos, 5
+    goto alt767_end
+  alt767_2:
   # rx literal  "rule"
-    add $I11, rx775_pos, 4
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 4
-    ne $S10, "rule", rx775_fail
-    add rx775_pos, 4
-  alt797_end:
-    set_addr $I10, rxcap_798_fail
-    ($I12, $I11) = rx775_cur."!mark_peek"($I10)
-    rx775_cur."!cursor_pos"($I11)
-    ($P10) = rx775_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx775_pos, "")
-    rx775_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx745_pos, 4
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 4
+    ne $S10, "rule", rx745_fail
+    add rx745_pos, 4
+  alt767_end:
+    set_addr $I10, rxcap_768_fail
+    ($I12, $I11) = rx745_cur."!mark_peek"($I10)
+    rx745_cur."!cursor_pos"($I11)
+    ($P10) = rx745_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx745_pos, "")
+    rx745_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_798_done
-  rxcap_798_fail:
-    goto rx775_fail
-  rxcap_798_done:
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    goto rxcap_768_done
+  rxcap_768_fail:
+    goto rx745_fail
+  rxcap_768_done:
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 354
   # rx subrule "deflongname" subtype=capture negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."deflongname"()
-    unless $P10, rx775_fail
-    rx775_cur."!mark_push"(0, -1, 0, $P10)
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."deflongname"()
+    unless $P10, rx745_fail
+    rx745_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("deflongname")
-    rx775_pos = $P10."pos"()
+    rx745_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 355
   # rx subrule "newpad" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."newpad"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."newpad"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 356
-  # rx rxquantr802 ** 0..1
-    set_addr $I807, rxquantr802_done
-    rx775_cur."!mark_push"(0, rx775_pos, $I807)
-  rxquantr802_loop:
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+  # rx rxquantr772 ** 0..1
+    set_addr $I10, rxquantr772_done
+    rx745_cur."!mark_push"(0, rx745_pos, $I10)
+  rxquantr772_loop:
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx literal  "("
-    add $I11, rx775_pos, 1
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 1
-    ne $S10, "(", rx775_fail
-    add rx775_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    add $I11, rx745_pos, 1
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 1
+    ne $S10, "(", rx745_fail
+    add rx745_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx subrule "signature" subtype=capture negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."signature"()
-    unless $P10, rx775_fail
-    rx775_cur."!mark_push"(0, -1, 0, $P10)
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."signature"()
+    unless $P10, rx745_fail
+    rx745_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("signature")
-    rx775_pos = $P10."pos"()
+    rx745_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx775_pos, 1
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 1
-    ne $S10, ")", rx775_fail
-    add rx775_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-    (rx775_rep) = rx775_cur."!mark_commit"($I807)
-  rxquantr802_done:
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    add $I11, rx745_pos, 1
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 1
+    ne $S10, ")", rx745_fail
+    add rx745_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+    set_addr $I10, rxquantr772_done
+    (rx745_rep) = rx745_cur."!mark_commit"($I10)
+  rxquantr772_done:
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 357
   # rx reduce name="regex_declarator" key="open"
-    rx775_cur."!cursor_pos"(rx775_pos)
-    rx775_cur."!reduce"("regex_declarator", "open")
+    rx745_cur."!cursor_pos"(rx745_pos)
+    rx745_cur."!reduce"("regex_declarator", "open")
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 358
   # rx literal  "{"
-    add $I11, rx775_pos, 1
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 1
-    ne $S10, "{", rx775_fail
-    add rx775_pos, 1
+    add $I11, rx745_pos, 1
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 1
+    ne $S10, "{", rx745_fail
+    add rx745_pos, 1
   # rx subrule "LANG" subtype=capture negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."LANG"("Regex", "nibbler")
-    unless $P10, rx775_fail
-    rx775_cur."!mark_push"(0, -1, 0, $P10)
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."LANG"("Regex", "nibbler")
+    unless $P10, rx745_fail
+    rx745_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("p6regex")
-    rx775_pos = $P10."pos"()
+    rx745_pos = $P10."pos"()
   # rx literal  "}"
-    add $I11, rx775_pos, 1
-    gt $I11, rx775_eos, rx775_fail
-    sub $I11, rx775_pos, rx775_off
-    substr $S10, rx775_tgt, $I11, 1
-    ne $S10, "}", rx775_fail
-    add rx775_pos, 1
+    add $I11, rx745_pos, 1
+    gt $I11, rx745_eos, rx745_fail
+    sub $I11, rx745_pos, rx745_off
+    substr $S10, rx745_tgt, $I11, 1
+    ne $S10, "}", rx745_fail
+    add rx745_pos, 1
   # rx subrule "ENDSTMT" subtype=zerowidth negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ENDSTMT"()
-    unless $P10, rx775_fail
-  # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
-  alt781_end:
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ENDSTMT"()
+    unless $P10, rx745_fail
+  # rx subrule "ws" subtype=method negate=
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
+  alt751_end:
 .annotate 'line', 359
   # rx subrule "ws" subtype=method negate=
-    rx775_cur."!cursor_pos"(rx775_pos)
-    $P10 = rx775_cur."ws"()
-    unless $P10, rx775_fail
-    rx775_pos = $P10."pos"()
+    rx745_cur."!cursor_pos"(rx745_pos)
+    $P10 = rx745_cur."ws"()
+    unless $P10, rx745_fail
+    rx745_pos = $P10."pos"()
 .annotate 'line', 345
   # rx pass
-    rx775_cur."!cursor_pass"(rx775_pos, "regex_declarator")
-    rx775_cur."!cursor_debug"("PASS  ", "regex_declarator", " at pos=", rx775_pos)
-    .return (rx775_cur)
-  rx775_fail:
+    rx745_cur."!cursor_pass"(rx745_pos, "regex_declarator")
+    rx745_cur."!cursor_debug"("PASS  ", "regex_declarator", " at pos=", rx745_pos)
+    .return (rx745_cur)
+  rx745_restart:
 .annotate 'line', 4
-    (rx775_rep, rx775_pos, $I10, $P10) = rx775_cur."!mark_fail"(0)
-    lt rx775_pos, -1, rx775_done
-    eq rx775_pos, -1, rx775_fail
+    rx745_cur."!cursor_debug"("NEXT ", "regex_declarator")
+  rx745_fail:
+    (rx745_rep, rx745_pos, $I10, $P10) = rx745_cur."!mark_fail"(0)
+    lt rx745_pos, -1, rx745_done
+    eq rx745_pos, -1, rx745_fail
     jump $I10
-  rx775_done:
-    rx775_cur."!cursor_fail"()
-    rx775_cur."!cursor_debug"("FAIL  ", "regex_declarator")
-    .return (rx775_cur)
+  rx745_done:
+    rx745_cur."!cursor_fail"()
+    rx745_cur."!cursor_debug"("FAIL  ", "regex_declarator")
+    .return (rx745_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__regex_declarator"  :subid("181_1278500537.15927") :method
+.sub "!PREFIX__regex_declarator"  :subid("181_1279529226.73787") :method
 .annotate 'line', 4
-    $P777 = self."!PREFIX__!subrule"("ws", "")
-    new $P778, "ResizablePMCArray"
-    push $P778, $P777
-    .return ($P778)
+    $P747 = self."!PREFIX__!subrule"("ws", "")
+    new $P748, "ResizablePMCArray"
+    push $P748, $P747
+    .return ($P748)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "dotty"  :subid("182_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "dotty"  :subid("182_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx813_tgt
-    .local int rx813_pos
-    .local int rx813_off
-    .local int rx813_eos
-    .local int rx813_rep
-    .local pmc rx813_cur
-    (rx813_cur, rx813_pos, rx813_tgt) = self."!cursor_start"()
-    rx813_cur."!cursor_debug"("START ", "dotty")
-    rx813_cur."!cursor_caparray"("args")
-    .lex unicode:"$\x{a2}", rx813_cur
-    .local pmc match
-    .lex "$/", match
-    length rx813_eos, rx813_tgt
-    gt rx813_pos, rx813_eos, rx813_done
-    set rx813_off, 0
-    lt rx813_pos, 2, rx813_start
-    sub rx813_off, rx813_pos, 1
-    substr rx813_tgt, rx813_tgt, rx813_off
-  rx813_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan817_done
-    goto rxscan817_scan
-  rxscan817_loop:
-    ($P10) = rx813_cur."from"()
-    inc $P10
-    set rx813_pos, $P10
-    ge rx813_pos, rx813_eos, rxscan817_done
-  rxscan817_scan:
-    set_addr $I10, rxscan817_loop
-    rx813_cur."!mark_push"(0, rx813_pos, $I10)
-  rxscan817_done:
+    .local string rx782_tgt
+    .local int rx782_pos
+    .local int rx782_off
+    .local int rx782_eos
+    .local int rx782_rep
+    .local pmc rx782_cur
+    (rx782_cur, rx782_pos, rx782_tgt, $I10) = self."!cursor_start"()
+    rx782_cur."!cursor_caparray"("args")
+    .lex unicode:"$\x{a2}", rx782_cur
+    .local pmc match
+    .lex "$/", match
+    length rx782_eos, rx782_tgt
+    gt rx782_pos, rx782_eos, rx782_done
+    set rx782_off, 0
+    lt rx782_pos, 2, rx782_start
+    sub rx782_off, rx782_pos, 1
+    substr rx782_tgt, rx782_tgt, rx782_off
+  rx782_start:
+    eq $I10, 1, rx782_restart
+    rx782_cur."!cursor_debug"("START ", "dotty")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan786_done
+    goto rxscan786_scan
+  rxscan786_loop:
+    ($P10) = rx782_cur."from"()
+    inc $P10
+    set rx782_pos, $P10
+    ge rx782_pos, rx782_eos, rxscan786_done
+  rxscan786_scan:
+    set_addr $I10, rxscan786_loop
+    rx782_cur."!mark_push"(0, rx782_pos, $I10)
+  rxscan786_done:
 .annotate 'line', 363
   # rx literal  "."
-    add $I11, rx813_pos, 1
-    gt $I11, rx813_eos, rx813_fail
-    sub $I11, rx813_pos, rx813_off
-    substr $S10, rx813_tgt, $I11, 1
-    ne $S10, ".", rx813_fail
-    add rx813_pos, 1
-  alt818_0:
+    add $I11, rx782_pos, 1
+    gt $I11, rx782_eos, rx782_fail
+    sub $I11, rx782_pos, rx782_off
+    substr $S10, rx782_tgt, $I11, 1
+    ne $S10, ".", rx782_fail
+    add rx782_pos, 1
+  alt787_0:
 .annotate 'line', 364
-    set_addr $I10, alt818_1
-    rx813_cur."!mark_push"(0, rx813_pos, $I10)
+    set_addr $I10, alt787_1
+    rx782_cur."!mark_push"(0, rx782_pos, $I10)
   # rx subrule "deflongname" subtype=capture negate=
-    rx813_cur."!cursor_pos"(rx813_pos)
-    $P10 = rx813_cur."deflongname"()
-    unless $P10, rx813_fail
-    rx813_cur."!mark_push"(0, -1, 0, $P10)
+    rx782_cur."!cursor_pos"(rx782_pos)
+    $P10 = rx782_cur."deflongname"()
+    unless $P10, rx782_fail
+    rx782_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("longname=deflongname")
-    rx813_pos = $P10."pos"()
-    goto alt818_end
-  alt818_1:
+    rx782_pos = $P10."pos"()
+    goto alt787_end
+  alt787_1:
 .annotate 'line', 365
   # rx enumcharlist negate=0 zerowidth
-    ge rx813_pos, rx813_eos, rx813_fail
-    sub $I10, rx813_pos, rx813_off
-    substr $S10, rx813_tgt, $I10, 1
+    ge rx782_pos, rx782_eos, rx782_fail
+    sub $I10, rx782_pos, rx782_off
+    substr $S10, rx782_tgt, $I10, 1
     index $I11, "'\"", $S10
-    lt $I11, 0, rx813_fail
+    lt $I11, 0, rx782_fail
   # rx subrule "quote" subtype=capture negate=
-    rx813_cur."!cursor_pos"(rx813_pos)
-    $P10 = rx813_cur."quote"()
-    unless $P10, rx813_fail
-    rx813_cur."!mark_push"(0, -1, 0, $P10)
+    rx782_cur."!cursor_pos"(rx782_pos)
+    $P10 = rx782_cur."quote"()
+    unless $P10, rx782_fail
+    rx782_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote")
-    rx813_pos = $P10."pos"()
-  alt819_0:
+    rx782_pos = $P10."pos"()
+  alt788_0:
 .annotate 'line', 366
-    set_addr $I10, alt819_1
-    rx813_cur."!mark_push"(0, rx813_pos, $I10)
+    set_addr $I10, alt788_1
+    rx782_cur."!mark_push"(0, rx782_pos, $I10)
   # rx enumcharlist negate=0 zerowidth
-    ge rx813_pos, rx813_eos, rx813_fail
-    sub $I10, rx813_pos, rx813_off
-    substr $S10, rx813_tgt, $I10, 1
+    ge rx782_pos, rx782_eos, rx782_fail
+    sub $I10, rx782_pos, rx782_off
+    substr $S10, rx782_tgt, $I10, 1
     index $I11, "(", $S10
-    lt $I11, 0, rx813_fail
-    goto alt819_end
-  alt819_1:
+    lt $I11, 0, rx782_fail
+    goto alt788_end
+  alt788_1:
   # rx subrule "panic" subtype=method negate=
-    rx813_cur."!cursor_pos"(rx813_pos)
-    $P10 = rx813_cur."panic"("Quoted method name requires parenthesized arguments")
-    unless $P10, rx813_fail
-    rx813_pos = $P10."pos"()
-  alt819_end:
-  alt818_end:
+    rx782_cur."!cursor_pos"(rx782_pos)
+    $P10 = rx782_cur."panic"("Quoted method name requires parenthesized arguments")
+    unless $P10, rx782_fail
+    rx782_pos = $P10."pos"()
+  alt788_end:
+  alt787_end:
 .annotate 'line', 372
-  # rx rxquantr820 ** 0..1
-    set_addr $I822, rxquantr820_done
-    rx813_cur."!mark_push"(0, rx813_pos, $I822)
-  rxquantr820_loop:
-  alt821_0:
+  # rx rxquantr789 ** 0..1
+    set_addr $I10, rxquantr789_done
+    rx782_cur."!mark_push"(0, rx782_pos, $I10)
+  rxquantr789_loop:
+  alt790_0:
 .annotate 'line', 369
-    set_addr $I10, alt821_1
-    rx813_cur."!mark_push"(0, rx813_pos, $I10)
+    set_addr $I10, alt790_1
+    rx782_cur."!mark_push"(0, rx782_pos, $I10)
 .annotate 'line', 370
   # rx enumcharlist negate=0 zerowidth
-    ge rx813_pos, rx813_eos, rx813_fail
-    sub $I10, rx813_pos, rx813_off
-    substr $S10, rx813_tgt, $I10, 1
+    ge rx782_pos, rx782_eos, rx782_fail
+    sub $I10, rx782_pos, rx782_off
+    substr $S10, rx782_tgt, $I10, 1
     index $I11, "(", $S10
-    lt $I11, 0, rx813_fail
+    lt $I11, 0, rx782_fail
   # rx subrule "args" subtype=capture negate=
-    rx813_cur."!cursor_pos"(rx813_pos)
-    $P10 = rx813_cur."args"()
-    unless $P10, rx813_fail
-    rx813_cur."!mark_push"(0, -1, 0, $P10)
+    rx782_cur."!cursor_pos"(rx782_pos)
+    $P10 = rx782_cur."args"()
+    unless $P10, rx782_fail
+    rx782_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("args")
-    rx813_pos = $P10."pos"()
-    goto alt821_end
-  alt821_1:
+    rx782_pos = $P10."pos"()
+    goto alt790_end
+  alt790_1:
 .annotate 'line', 371
   # rx literal  ":"
-    add $I11, rx813_pos, 1
-    gt $I11, rx813_eos, rx813_fail
-    sub $I11, rx813_pos, rx813_off
-    substr $S10, rx813_tgt, $I11, 1
-    ne $S10, ":", rx813_fail
-    add rx813_pos, 1
+    add $I11, rx782_pos, 1
+    gt $I11, rx782_eos, rx782_fail
+    sub $I11, rx782_pos, rx782_off
+    substr $S10, rx782_tgt, $I11, 1
+    ne $S10, ":", rx782_fail
+    add rx782_pos, 1
   # rx charclass s
-    ge rx813_pos, rx813_eos, rx813_fail
-    sub $I10, rx813_pos, rx813_off
-    is_cclass $I11, 32, rx813_tgt, $I10
-    unless $I11, rx813_fail
-    inc rx813_pos
+    ge rx782_pos, rx782_eos, rx782_fail
+    sub $I10, rx782_pos, rx782_off
+    is_cclass $I11, 32, rx782_tgt, $I10
+    unless $I11, rx782_fail
+    inc rx782_pos
   # rx subrule "arglist" subtype=capture negate=
-    rx813_cur."!cursor_pos"(rx813_pos)
-    $P10 = rx813_cur."arglist"()
-    unless $P10, rx813_fail
-    rx813_cur."!mark_push"(0, -1, 0, $P10)
+    rx782_cur."!cursor_pos"(rx782_pos)
+    $P10 = rx782_cur."arglist"()
+    unless $P10, rx782_fail
+    rx782_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("args")
-    rx813_pos = $P10."pos"()
-  alt821_end:
+    rx782_pos = $P10."pos"()
+  alt790_end:
 .annotate 'line', 372
-    (rx813_rep) = rx813_cur."!mark_commit"($I822)
-  rxquantr820_done:
+    set_addr $I10, rxquantr789_done
+    (rx782_rep) = rx782_cur."!mark_commit"($I10)
+  rxquantr789_done:
 .annotate 'line', 362
   # rx pass
-    rx813_cur."!cursor_pass"(rx813_pos, "dotty")
-    rx813_cur."!cursor_debug"("PASS  ", "dotty", " at pos=", rx813_pos)
-    .return (rx813_cur)
-  rx813_fail:
+    rx782_cur."!cursor_pass"(rx782_pos, "dotty")
+    rx782_cur."!cursor_debug"("PASS  ", "dotty", " at pos=", rx782_pos)
+    .return (rx782_cur)
+  rx782_restart:
 .annotate 'line', 4
-    (rx813_rep, rx813_pos, $I10, $P10) = rx813_cur."!mark_fail"(0)
-    lt rx813_pos, -1, rx813_done
-    eq rx813_pos, -1, rx813_fail
+    rx782_cur."!cursor_debug"("NEXT ", "dotty")
+  rx782_fail:
+    (rx782_rep, rx782_pos, $I10, $P10) = rx782_cur."!mark_fail"(0)
+    lt rx782_pos, -1, rx782_done
+    eq rx782_pos, -1, rx782_fail
     jump $I10
-  rx813_done:
-    rx813_cur."!cursor_fail"()
-    rx813_cur."!cursor_debug"("FAIL  ", "dotty")
-    .return (rx813_cur)
+  rx782_done:
+    rx782_cur."!cursor_fail"()
+    rx782_cur."!cursor_debug"("FAIL  ", "dotty")
+    .return (rx782_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__dotty"  :subid("183_1278500537.15927") :method
+.sub "!PREFIX__dotty"  :subid("183_1279529226.73787") :method
 .annotate 'line', 4
-    $P815 = self."!PREFIX__!subrule"("deflongname", ".")
-    new $P816, "ResizablePMCArray"
-    push $P816, "'"
-    push $P816, "\""
-    push $P816, $P815
-    .return ($P816)
+    $P784 = self."!PREFIX__!subrule"("deflongname", ".")
+    new $P785, "ResizablePMCArray"
+    push $P785, "'"
+    push $P785, "\""
+    push $P785, $P784
+    .return ($P785)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term"  :subid("184_1278500537.15927") :method
+.sub "term"  :subid("184_1279529226.73787") :method
 .annotate 'line', 376
-    $P824 = self."!protoregex"("term")
-    .return ($P824)
+    $P792 = self."!protoregex"("term")
+    .return ($P792)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term"  :subid("185_1278500537.15927") :method
+.sub "!PREFIX__term"  :subid("185_1279529226.73787") :method
 .annotate 'line', 376
-    $P826 = self."!PREFIX__!protoregex"("term")
-    .return ($P826)
+    $P794 = self."!PREFIX__!protoregex"("term")
+    .return ($P794)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<self>"  :subid("186_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<self>"  :subid("186_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx828_tgt
-    .local int rx828_pos
-    .local int rx828_off
-    .local int rx828_eos
-    .local int rx828_rep
-    .local pmc rx828_cur
-    (rx828_cur, rx828_pos, rx828_tgt) = self."!cursor_start"()
-    rx828_cur."!cursor_debug"("START ", "term:sym<self>")
-    .lex unicode:"$\x{a2}", rx828_cur
-    .local pmc match
-    .lex "$/", match
-    length rx828_eos, rx828_tgt
-    gt rx828_pos, rx828_eos, rx828_done
-    set rx828_off, 0
-    lt rx828_pos, 2, rx828_start
-    sub rx828_off, rx828_pos, 1
-    substr rx828_tgt, rx828_tgt, rx828_off
-  rx828_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan831_done
-    goto rxscan831_scan
-  rxscan831_loop:
-    ($P10) = rx828_cur."from"()
-    inc $P10
-    set rx828_pos, $P10
-    ge rx828_pos, rx828_eos, rxscan831_done
-  rxscan831_scan:
-    set_addr $I10, rxscan831_loop
-    rx828_cur."!mark_push"(0, rx828_pos, $I10)
-  rxscan831_done:
+    .local string rx796_tgt
+    .local int rx796_pos
+    .local int rx796_off
+    .local int rx796_eos
+    .local int rx796_rep
+    .local pmc rx796_cur
+    (rx796_cur, rx796_pos, rx796_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx796_cur
+    .local pmc match
+    .lex "$/", match
+    length rx796_eos, rx796_tgt
+    gt rx796_pos, rx796_eos, rx796_done
+    set rx796_off, 0
+    lt rx796_pos, 2, rx796_start
+    sub rx796_off, rx796_pos, 1
+    substr rx796_tgt, rx796_tgt, rx796_off
+  rx796_start:
+    eq $I10, 1, rx796_restart
+    rx796_cur."!cursor_debug"("START ", "term:sym<self>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan799_done
+    goto rxscan799_scan
+  rxscan799_loop:
+    ($P10) = rx796_cur."from"()
+    inc $P10
+    set rx796_pos, $P10
+    ge rx796_pos, rx796_eos, rxscan799_done
+  rxscan799_scan:
+    set_addr $I10, rxscan799_loop
+    rx796_cur."!mark_push"(0, rx796_pos, $I10)
+  rxscan799_done:
 .annotate 'line', 378
   # rx subcapture "sym"
-    set_addr $I10, rxcap_832_fail
-    rx828_cur."!mark_push"(0, rx828_pos, $I10)
+    set_addr $I10, rxcap_800_fail
+    rx796_cur."!mark_push"(0, rx796_pos, $I10)
   # rx literal  "self"
-    add $I11, rx828_pos, 4
-    gt $I11, rx828_eos, rx828_fail
-    sub $I11, rx828_pos, rx828_off
-    substr $S10, rx828_tgt, $I11, 4
-    ne $S10, "self", rx828_fail
-    add rx828_pos, 4
-    set_addr $I10, rxcap_832_fail
-    ($I12, $I11) = rx828_cur."!mark_peek"($I10)
-    rx828_cur."!cursor_pos"($I11)
-    ($P10) = rx828_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx828_pos, "")
-    rx828_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx796_pos, 4
+    gt $I11, rx796_eos, rx796_fail
+    sub $I11, rx796_pos, rx796_off
+    substr $S10, rx796_tgt, $I11, 4
+    ne $S10, "self", rx796_fail
+    add rx796_pos, 4
+    set_addr $I10, rxcap_800_fail
+    ($I12, $I11) = rx796_cur."!mark_peek"($I10)
+    rx796_cur."!cursor_pos"($I11)
+    ($P10) = rx796_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx796_pos, "")
+    rx796_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_832_done
-  rxcap_832_fail:
-    goto rx828_fail
-  rxcap_832_done:
+    goto rxcap_800_done
+  rxcap_800_fail:
+    goto rx796_fail
+  rxcap_800_done:
   # rxanchor rwb
-    le rx828_pos, 0, rx828_fail
-    sub $I10, rx828_pos, rx828_off
-    is_cclass $I11, 8192, rx828_tgt, $I10
-    if $I11, rx828_fail
+    le rx796_pos, 0, rx796_fail
+    sub $I10, rx796_pos, rx796_off
+    is_cclass $I11, 8192, rx796_tgt, $I10
+    if $I11, rx796_fail
     dec $I10
-    is_cclass $I11, 8192, rx828_tgt, $I10
-    unless $I11, rx828_fail
+    is_cclass $I11, 8192, rx796_tgt, $I10
+    unless $I11, rx796_fail
   # rx pass
-    rx828_cur."!cursor_pass"(rx828_pos, "term:sym<self>")
-    rx828_cur."!cursor_debug"("PASS  ", "term:sym<self>", " at pos=", rx828_pos)
-    .return (rx828_cur)
-  rx828_fail:
+    rx796_cur."!cursor_pass"(rx796_pos, "term:sym<self>")
+    rx796_cur."!cursor_debug"("PASS  ", "term:sym<self>", " at pos=", rx796_pos)
+    .return (rx796_cur)
+  rx796_restart:
 .annotate 'line', 4
-    (rx828_rep, rx828_pos, $I10, $P10) = rx828_cur."!mark_fail"(0)
-    lt rx828_pos, -1, rx828_done
-    eq rx828_pos, -1, rx828_fail
+    rx796_cur."!cursor_debug"("NEXT ", "term:sym<self>")
+  rx796_fail:
+    (rx796_rep, rx796_pos, $I10, $P10) = rx796_cur."!mark_fail"(0)
+    lt rx796_pos, -1, rx796_done
+    eq rx796_pos, -1, rx796_fail
     jump $I10
-  rx828_done:
-    rx828_cur."!cursor_fail"()
-    rx828_cur."!cursor_debug"("FAIL  ", "term:sym<self>")
-    .return (rx828_cur)
+  rx796_done:
+    rx796_cur."!cursor_fail"()
+    rx796_cur."!cursor_debug"("FAIL  ", "term:sym<self>")
+    .return (rx796_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<self>"  :subid("187_1278500537.15927") :method
+.sub "!PREFIX__term:sym<self>"  :subid("187_1279529226.73787") :method
 .annotate 'line', 4
-    new $P830, "ResizablePMCArray"
-    push $P830, "self"
-    .return ($P830)
+    new $P798, "ResizablePMCArray"
+    push $P798, "self"
+    .return ($P798)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<identifier>"  :subid("188_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<identifier>"  :subid("188_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx834_tgt
-    .local int rx834_pos
-    .local int rx834_off
-    .local int rx834_eos
-    .local int rx834_rep
-    .local pmc rx834_cur
-    (rx834_cur, rx834_pos, rx834_tgt) = self."!cursor_start"()
-    rx834_cur."!cursor_debug"("START ", "term:sym<identifier>")
-    .lex unicode:"$\x{a2}", rx834_cur
-    .local pmc match
-    .lex "$/", match
-    length rx834_eos, rx834_tgt
-    gt rx834_pos, rx834_eos, rx834_done
-    set rx834_off, 0
-    lt rx834_pos, 2, rx834_start
-    sub rx834_off, rx834_pos, 1
-    substr rx834_tgt, rx834_tgt, rx834_off
-  rx834_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan838_done
-    goto rxscan838_scan
-  rxscan838_loop:
-    ($P10) = rx834_cur."from"()
-    inc $P10
-    set rx834_pos, $P10
-    ge rx834_pos, rx834_eos, rxscan838_done
-  rxscan838_scan:
-    set_addr $I10, rxscan838_loop
-    rx834_cur."!mark_push"(0, rx834_pos, $I10)
-  rxscan838_done:
+    .local string rx802_tgt
+    .local int rx802_pos
+    .local int rx802_off
+    .local int rx802_eos
+    .local int rx802_rep
+    .local pmc rx802_cur
+    (rx802_cur, rx802_pos, rx802_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx802_cur
+    .local pmc match
+    .lex "$/", match
+    length rx802_eos, rx802_tgt
+    gt rx802_pos, rx802_eos, rx802_done
+    set rx802_off, 0
+    lt rx802_pos, 2, rx802_start
+    sub rx802_off, rx802_pos, 1
+    substr rx802_tgt, rx802_tgt, rx802_off
+  rx802_start:
+    eq $I10, 1, rx802_restart
+    rx802_cur."!cursor_debug"("START ", "term:sym<identifier>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan806_done
+    goto rxscan806_scan
+  rxscan806_loop:
+    ($P10) = rx802_cur."from"()
+    inc $P10
+    set rx802_pos, $P10
+    ge rx802_pos, rx802_eos, rxscan806_done
+  rxscan806_scan:
+    set_addr $I10, rxscan806_loop
+    rx802_cur."!mark_push"(0, rx802_pos, $I10)
+  rxscan806_done:
 .annotate 'line', 381
   # rx subrule "deflongname" subtype=capture negate=
-    rx834_cur."!cursor_pos"(rx834_pos)
-    $P10 = rx834_cur."deflongname"()
-    unless $P10, rx834_fail
-    rx834_cur."!mark_push"(0, -1, 0, $P10)
+    rx802_cur."!cursor_pos"(rx802_pos)
+    $P10 = rx802_cur."deflongname"()
+    unless $P10, rx802_fail
+    rx802_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("deflongname")
-    rx834_pos = $P10."pos"()
+    rx802_pos = $P10."pos"()
   # rx enumcharlist negate=0 zerowidth
-    ge rx834_pos, rx834_eos, rx834_fail
-    sub $I10, rx834_pos, rx834_off
-    substr $S10, rx834_tgt, $I10, 1
+    ge rx802_pos, rx802_eos, rx802_fail
+    sub $I10, rx802_pos, rx802_off
+    substr $S10, rx802_tgt, $I10, 1
     index $I11, "(", $S10
-    lt $I11, 0, rx834_fail
+    lt $I11, 0, rx802_fail
   # rx subrule "args" subtype=capture negate=
-    rx834_cur."!cursor_pos"(rx834_pos)
-    $P10 = rx834_cur."args"()
-    unless $P10, rx834_fail
-    rx834_cur."!mark_push"(0, -1, 0, $P10)
+    rx802_cur."!cursor_pos"(rx802_pos)
+    $P10 = rx802_cur."args"()
+    unless $P10, rx802_fail
+    rx802_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("args")
-    rx834_pos = $P10."pos"()
+    rx802_pos = $P10."pos"()
 .annotate 'line', 380
   # rx pass
-    rx834_cur."!cursor_pass"(rx834_pos, "term:sym<identifier>")
-    rx834_cur."!cursor_debug"("PASS  ", "term:sym<identifier>", " at pos=", rx834_pos)
-    .return (rx834_cur)
-  rx834_fail:
+    rx802_cur."!cursor_pass"(rx802_pos, "term:sym<identifier>")
+    rx802_cur."!cursor_debug"("PASS  ", "term:sym<identifier>", " at pos=", rx802_pos)
+    .return (rx802_cur)
+  rx802_restart:
 .annotate 'line', 4
-    (rx834_rep, rx834_pos, $I10, $P10) = rx834_cur."!mark_fail"(0)
-    lt rx834_pos, -1, rx834_done
-    eq rx834_pos, -1, rx834_fail
+    rx802_cur."!cursor_debug"("NEXT ", "term:sym<identifier>")
+  rx802_fail:
+    (rx802_rep, rx802_pos, $I10, $P10) = rx802_cur."!mark_fail"(0)
+    lt rx802_pos, -1, rx802_done
+    eq rx802_pos, -1, rx802_fail
     jump $I10
-  rx834_done:
-    rx834_cur."!cursor_fail"()
-    rx834_cur."!cursor_debug"("FAIL  ", "term:sym<identifier>")
-    .return (rx834_cur)
+  rx802_done:
+    rx802_cur."!cursor_fail"()
+    rx802_cur."!cursor_debug"("FAIL  ", "term:sym<identifier>")
+    .return (rx802_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<identifier>"  :subid("189_1278500537.15927") :method
+.sub "!PREFIX__term:sym<identifier>"  :subid("189_1279529226.73787") :method
 .annotate 'line', 4
-    $P836 = self."!PREFIX__!subrule"("deflongname", "")
-    new $P837, "ResizablePMCArray"
-    push $P837, $P836
-    .return ($P837)
+    $P804 = self."!PREFIX__!subrule"("deflongname", "")
+    new $P805, "ResizablePMCArray"
+    push $P805, $P804
+    .return ($P805)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<name>"  :subid("190_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<name>"  :subid("190_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx840_tgt
-    .local int rx840_pos
-    .local int rx840_off
-    .local int rx840_eos
-    .local int rx840_rep
-    .local pmc rx840_cur
-    (rx840_cur, rx840_pos, rx840_tgt) = self."!cursor_start"()
-    rx840_cur."!cursor_debug"("START ", "term:sym<name>")
-    rx840_cur."!cursor_caparray"("args")
-    .lex unicode:"$\x{a2}", rx840_cur
+    .local string rx808_tgt
+    .local int rx808_pos
+    .local int rx808_off
+    .local int rx808_eos
+    .local int rx808_rep
+    .local pmc rx808_cur
+    (rx808_cur, rx808_pos, rx808_tgt, $I10) = self."!cursor_start"()
+    rx808_cur."!cursor_caparray"("args")
+    .lex unicode:"$\x{a2}", rx808_cur
     .local pmc match
     .lex "$/", match
-    length rx840_eos, rx840_tgt
-    gt rx840_pos, rx840_eos, rx840_done
-    set rx840_off, 0
-    lt rx840_pos, 2, rx840_start
-    sub rx840_off, rx840_pos, 1
-    substr rx840_tgt, rx840_tgt, rx840_off
-  rx840_start:
+    length rx808_eos, rx808_tgt
+    gt rx808_pos, rx808_eos, rx808_done
+    set rx808_off, 0
+    lt rx808_pos, 2, rx808_start
+    sub rx808_off, rx808_pos, 1
+    substr rx808_tgt, rx808_tgt, rx808_off
+  rx808_start:
+    eq $I10, 1, rx808_restart
+    rx808_cur."!cursor_debug"("START ", "term:sym<name>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan844_done
-    goto rxscan844_scan
-  rxscan844_loop:
-    ($P10) = rx840_cur."from"()
+    ne $I10, -1, rxscan812_done
+    goto rxscan812_scan
+  rxscan812_loop:
+    ($P10) = rx808_cur."from"()
     inc $P10
-    set rx840_pos, $P10
-    ge rx840_pos, rx840_eos, rxscan844_done
-  rxscan844_scan:
-    set_addr $I10, rxscan844_loop
-    rx840_cur."!mark_push"(0, rx840_pos, $I10)
-  rxscan844_done:
+    set rx808_pos, $P10
+    ge rx808_pos, rx808_eos, rxscan812_done
+  rxscan812_scan:
+    set_addr $I10, rxscan812_loop
+    rx808_cur."!mark_push"(0, rx808_pos, $I10)
+  rxscan812_done:
 .annotate 'line', 385
   # rx subrule "name" subtype=capture negate=
-    rx840_cur."!cursor_pos"(rx840_pos)
-    $P10 = rx840_cur."name"()
-    unless $P10, rx840_fail
-    rx840_cur."!mark_push"(0, -1, 0, $P10)
+    rx808_cur."!cursor_pos"(rx808_pos)
+    $P10 = rx808_cur."name"()
+    unless $P10, rx808_fail
+    rx808_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("name")
-    rx840_pos = $P10."pos"()
-  # rx rxquantr845 ** 0..1
-    set_addr $I846, rxquantr845_done
-    rx840_cur."!mark_push"(0, rx840_pos, $I846)
-  rxquantr845_loop:
+    rx808_pos = $P10."pos"()
+  # rx rxquantr813 ** 0..1
+    set_addr $I10, rxquantr813_done
+    rx808_cur."!mark_push"(0, rx808_pos, $I10)
+  rxquantr813_loop:
   # rx subrule "args" subtype=capture negate=
-    rx840_cur."!cursor_pos"(rx840_pos)
-    $P10 = rx840_cur."args"()
-    unless $P10, rx840_fail
-    rx840_cur."!mark_push"(0, -1, 0, $P10)
+    rx808_cur."!cursor_pos"(rx808_pos)
+    $P10 = rx808_cur."args"()
+    unless $P10, rx808_fail
+    goto rxsubrule814_pass
+  rxsubrule814_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx808_fail
+  rxsubrule814_pass:
+    set_addr $I10, rxsubrule814_back
+    rx808_cur."!mark_push"(0, rx808_pos, $I10, $P10)
     $P10."!cursor_names"("args")
-    rx840_pos = $P10."pos"()
-    (rx840_rep) = rx840_cur."!mark_commit"($I846)
-  rxquantr845_done:
+    rx808_pos = $P10."pos"()
+    set_addr $I10, rxquantr813_done
+    (rx808_rep) = rx808_cur."!mark_commit"($I10)
+  rxquantr813_done:
 .annotate 'line', 384
   # rx pass
-    rx840_cur."!cursor_pass"(rx840_pos, "term:sym<name>")
-    rx840_cur."!cursor_debug"("PASS  ", "term:sym<name>", " at pos=", rx840_pos)
-    .return (rx840_cur)
-  rx840_fail:
+    rx808_cur."!cursor_pass"(rx808_pos, "term:sym<name>")
+    rx808_cur."!cursor_debug"("PASS  ", "term:sym<name>", " at pos=", rx808_pos)
+    .return (rx808_cur)
+  rx808_restart:
 .annotate 'line', 4
-    (rx840_rep, rx840_pos, $I10, $P10) = rx840_cur."!mark_fail"(0)
-    lt rx840_pos, -1, rx840_done
-    eq rx840_pos, -1, rx840_fail
+    rx808_cur."!cursor_debug"("NEXT ", "term:sym<name>")
+  rx808_fail:
+    (rx808_rep, rx808_pos, $I10, $P10) = rx808_cur."!mark_fail"(0)
+    lt rx808_pos, -1, rx808_done
+    eq rx808_pos, -1, rx808_fail
     jump $I10
-  rx840_done:
-    rx840_cur."!cursor_fail"()
-    rx840_cur."!cursor_debug"("FAIL  ", "term:sym<name>")
-    .return (rx840_cur)
+  rx808_done:
+    rx808_cur."!cursor_fail"()
+    rx808_cur."!cursor_debug"("FAIL  ", "term:sym<name>")
+    .return (rx808_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<name>"  :subid("191_1278500537.15927") :method
+.sub "!PREFIX__term:sym<name>"  :subid("191_1279529226.73787") :method
 .annotate 'line', 4
-    $P842 = self."!PREFIX__!subrule"("name", "")
-    new $P843, "ResizablePMCArray"
-    push $P843, $P842
-    .return ($P843)
+    $P810 = self."!PREFIX__!subrule"("name", "")
+    new $P811, "ResizablePMCArray"
+    push $P811, $P810
+    .return ($P811)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<pir::op>"  :subid("192_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<pir::op>"  :subid("192_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx848_tgt
-    .local int rx848_pos
-    .local int rx848_off
-    .local int rx848_eos
-    .local int rx848_rep
-    .local pmc rx848_cur
-    (rx848_cur, rx848_pos, rx848_tgt) = self."!cursor_start"()
-    rx848_cur."!cursor_debug"("START ", "term:sym<pir::op>")
-    rx848_cur."!cursor_caparray"("args")
-    .lex unicode:"$\x{a2}", rx848_cur
+    .local string rx816_tgt
+    .local int rx816_pos
+    .local int rx816_off
+    .local int rx816_eos
+    .local int rx816_rep
+    .local pmc rx816_cur
+    (rx816_cur, rx816_pos, rx816_tgt, $I10) = self."!cursor_start"()
+    rx816_cur."!cursor_caparray"("args")
+    .lex unicode:"$\x{a2}", rx816_cur
     .local pmc match
     .lex "$/", match
-    length rx848_eos, rx848_tgt
-    gt rx848_pos, rx848_eos, rx848_done
-    set rx848_off, 0
-    lt rx848_pos, 2, rx848_start
-    sub rx848_off, rx848_pos, 1
-    substr rx848_tgt, rx848_tgt, rx848_off
-  rx848_start:
+    length rx816_eos, rx816_tgt
+    gt rx816_pos, rx816_eos, rx816_done
+    set rx816_off, 0
+    lt rx816_pos, 2, rx816_start
+    sub rx816_off, rx816_pos, 1
+    substr rx816_tgt, rx816_tgt, rx816_off
+  rx816_start:
+    eq $I10, 1, rx816_restart
+    rx816_cur."!cursor_debug"("START ", "term:sym<pir::op>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan851_done
-    goto rxscan851_scan
-  rxscan851_loop:
-    ($P10) = rx848_cur."from"()
+    ne $I10, -1, rxscan819_done
+    goto rxscan819_scan
+  rxscan819_loop:
+    ($P10) = rx816_cur."from"()
     inc $P10
-    set rx848_pos, $P10
-    ge rx848_pos, rx848_eos, rxscan851_done
-  rxscan851_scan:
-    set_addr $I10, rxscan851_loop
-    rx848_cur."!mark_push"(0, rx848_pos, $I10)
-  rxscan851_done:
+    set rx816_pos, $P10
+    ge rx816_pos, rx816_eos, rxscan819_done
+  rxscan819_scan:
+    set_addr $I10, rxscan819_loop
+    rx816_cur."!mark_push"(0, rx816_pos, $I10)
+  rxscan819_done:
 .annotate 'line', 389
   # rx literal  "pir::"
-    add $I11, rx848_pos, 5
-    gt $I11, rx848_eos, rx848_fail
-    sub $I11, rx848_pos, rx848_off
-    substr $S10, rx848_tgt, $I11, 5
-    ne $S10, "pir::", rx848_fail
-    add rx848_pos, 5
+    add $I11, rx816_pos, 5
+    gt $I11, rx816_eos, rx816_fail
+    sub $I11, rx816_pos, rx816_off
+    substr $S10, rx816_tgt, $I11, 5
+    ne $S10, "pir::", rx816_fail
+    add rx816_pos, 5
   # rx subcapture "op"
-    set_addr $I10, rxcap_852_fail
-    rx848_cur."!mark_push"(0, rx848_pos, $I10)
+    set_addr $I10, rxcap_820_fail
+    rx816_cur."!mark_push"(0, rx816_pos, $I10)
   # rx charclass_q w r 1..-1
-    sub $I10, rx848_pos, rx848_off
-    find_not_cclass $I11, 8192, rx848_tgt, $I10, rx848_eos
+    sub $I10, rx816_pos, rx816_off
+    find_not_cclass $I11, 8192, rx816_tgt, $I10, rx816_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx848_fail
-    add rx848_pos, rx848_off, $I11
-    set_addr $I10, rxcap_852_fail
-    ($I12, $I11) = rx848_cur."!mark_peek"($I10)
-    rx848_cur."!cursor_pos"($I11)
-    ($P10) = rx848_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx848_pos, "")
-    rx848_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx816_fail
+    add rx816_pos, rx816_off, $I11
+    set_addr $I10, rxcap_820_fail
+    ($I12, $I11) = rx816_cur."!mark_peek"($I10)
+    rx816_cur."!cursor_pos"($I11)
+    ($P10) = rx816_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx816_pos, "")
+    rx816_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("op")
-    goto rxcap_852_done
-  rxcap_852_fail:
-    goto rx848_fail
-  rxcap_852_done:
-  # rx rxquantr853 ** 0..1
-    set_addr $I854, rxquantr853_done
-    rx848_cur."!mark_push"(0, rx848_pos, $I854)
-  rxquantr853_loop:
+    goto rxcap_820_done
+  rxcap_820_fail:
+    goto rx816_fail
+  rxcap_820_done:
+  # rx rxquantr821 ** 0..1
+    set_addr $I10, rxquantr821_done
+    rx816_cur."!mark_push"(0, rx816_pos, $I10)
+  rxquantr821_loop:
   # rx subrule "args" subtype=capture negate=
-    rx848_cur."!cursor_pos"(rx848_pos)
-    $P10 = rx848_cur."args"()
-    unless $P10, rx848_fail
-    rx848_cur."!mark_push"(0, -1, 0, $P10)
+    rx816_cur."!cursor_pos"(rx816_pos)
+    $P10 = rx816_cur."args"()
+    unless $P10, rx816_fail
+    goto rxsubrule822_pass
+  rxsubrule822_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx816_fail
+  rxsubrule822_pass:
+    set_addr $I10, rxsubrule822_back
+    rx816_cur."!mark_push"(0, rx816_pos, $I10, $P10)
     $P10."!cursor_names"("args")
-    rx848_pos = $P10."pos"()
-    (rx848_rep) = rx848_cur."!mark_commit"($I854)
-  rxquantr853_done:
+    rx816_pos = $P10."pos"()
+    set_addr $I10, rxquantr821_done
+    (rx816_rep) = rx816_cur."!mark_commit"($I10)
+  rxquantr821_done:
 .annotate 'line', 388
   # rx pass
-    rx848_cur."!cursor_pass"(rx848_pos, "term:sym<pir::op>")
-    rx848_cur."!cursor_debug"("PASS  ", "term:sym<pir::op>", " at pos=", rx848_pos)
-    .return (rx848_cur)
-  rx848_fail:
+    rx816_cur."!cursor_pass"(rx816_pos, "term:sym<pir::op>")
+    rx816_cur."!cursor_debug"("PASS  ", "term:sym<pir::op>", " at pos=", rx816_pos)
+    .return (rx816_cur)
+  rx816_restart:
 .annotate 'line', 4
-    (rx848_rep, rx848_pos, $I10, $P10) = rx848_cur."!mark_fail"(0)
-    lt rx848_pos, -1, rx848_done
-    eq rx848_pos, -1, rx848_fail
+    rx816_cur."!cursor_debug"("NEXT ", "term:sym<pir::op>")
+  rx816_fail:
+    (rx816_rep, rx816_pos, $I10, $P10) = rx816_cur."!mark_fail"(0)
+    lt rx816_pos, -1, rx816_done
+    eq rx816_pos, -1, rx816_fail
     jump $I10
-  rx848_done:
-    rx848_cur."!cursor_fail"()
-    rx848_cur."!cursor_debug"("FAIL  ", "term:sym<pir::op>")
-    .return (rx848_cur)
+  rx816_done:
+    rx816_cur."!cursor_fail"()
+    rx816_cur."!cursor_debug"("FAIL  ", "term:sym<pir::op>")
+    .return (rx816_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<pir::op>"  :subid("193_1278500537.15927") :method
+.sub "!PREFIX__term:sym<pir::op>"  :subid("193_1279529226.73787") :method
 .annotate 'line', 4
-    new $P850, "ResizablePMCArray"
-    push $P850, "pir::"
-    .return ($P850)
+    new $P818, "ResizablePMCArray"
+    push $P818, "pir::"
+    .return ($P818)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "args"  :subid("194_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "args"  :subid("194_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx856_tgt
-    .local int rx856_pos
-    .local int rx856_off
-    .local int rx856_eos
-    .local int rx856_rep
-    .local pmc rx856_cur
-    (rx856_cur, rx856_pos, rx856_tgt) = self."!cursor_start"()
-    rx856_cur."!cursor_debug"("START ", "args")
-    .lex unicode:"$\x{a2}", rx856_cur
-    .local pmc match
-    .lex "$/", match
-    length rx856_eos, rx856_tgt
-    gt rx856_pos, rx856_eos, rx856_done
-    set rx856_off, 0
-    lt rx856_pos, 2, rx856_start
-    sub rx856_off, rx856_pos, 1
-    substr rx856_tgt, rx856_tgt, rx856_off
-  rx856_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan860_done
-    goto rxscan860_scan
-  rxscan860_loop:
-    ($P10) = rx856_cur."from"()
-    inc $P10
-    set rx856_pos, $P10
-    ge rx856_pos, rx856_eos, rxscan860_done
-  rxscan860_scan:
-    set_addr $I10, rxscan860_loop
-    rx856_cur."!mark_push"(0, rx856_pos, $I10)
-  rxscan860_done:
+    .local string rx824_tgt
+    .local int rx824_pos
+    .local int rx824_off
+    .local int rx824_eos
+    .local int rx824_rep
+    .local pmc rx824_cur
+    (rx824_cur, rx824_pos, rx824_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx824_cur
+    .local pmc match
+    .lex "$/", match
+    length rx824_eos, rx824_tgt
+    gt rx824_pos, rx824_eos, rx824_done
+    set rx824_off, 0
+    lt rx824_pos, 2, rx824_start
+    sub rx824_off, rx824_pos, 1
+    substr rx824_tgt, rx824_tgt, rx824_off
+  rx824_start:
+    eq $I10, 1, rx824_restart
+    rx824_cur."!cursor_debug"("START ", "args")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan828_done
+    goto rxscan828_scan
+  rxscan828_loop:
+    ($P10) = rx824_cur."from"()
+    inc $P10
+    set rx824_pos, $P10
+    ge rx824_pos, rx824_eos, rxscan828_done
+  rxscan828_scan:
+    set_addr $I10, rxscan828_loop
+    rx824_cur."!mark_push"(0, rx824_pos, $I10)
+  rxscan828_done:
 .annotate 'line', 393
   # rx literal  "("
-    add $I11, rx856_pos, 1
-    gt $I11, rx856_eos, rx856_fail
-    sub $I11, rx856_pos, rx856_off
-    substr $S10, rx856_tgt, $I11, 1
-    ne $S10, "(", rx856_fail
-    add rx856_pos, 1
+    add $I11, rx824_pos, 1
+    gt $I11, rx824_eos, rx824_fail
+    sub $I11, rx824_pos, rx824_off
+    substr $S10, rx824_tgt, $I11, 1
+    ne $S10, "(", rx824_fail
+    add rx824_pos, 1
   # rx subrule "arglist" subtype=capture negate=
-    rx856_cur."!cursor_pos"(rx856_pos)
-    $P10 = rx856_cur."arglist"()
-    unless $P10, rx856_fail
-    rx856_cur."!mark_push"(0, -1, 0, $P10)
+    rx824_cur."!cursor_pos"(rx824_pos)
+    $P10 = rx824_cur."arglist"()
+    unless $P10, rx824_fail
+    rx824_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("arglist")
-    rx856_pos = $P10."pos"()
+    rx824_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx856_pos, 1
-    gt $I11, rx856_eos, rx856_fail
-    sub $I11, rx856_pos, rx856_off
-    substr $S10, rx856_tgt, $I11, 1
-    ne $S10, ")", rx856_fail
-    add rx856_pos, 1
+    add $I11, rx824_pos, 1
+    gt $I11, rx824_eos, rx824_fail
+    sub $I11, rx824_pos, rx824_off
+    substr $S10, rx824_tgt, $I11, 1
+    ne $S10, ")", rx824_fail
+    add rx824_pos, 1
   # rx pass
-    rx856_cur."!cursor_pass"(rx856_pos, "args")
-    rx856_cur."!cursor_debug"("PASS  ", "args", " at pos=", rx856_pos)
-    .return (rx856_cur)
-  rx856_fail:
+    rx824_cur."!cursor_pass"(rx824_pos, "args")
+    rx824_cur."!cursor_debug"("PASS  ", "args", " at pos=", rx824_pos)
+    .return (rx824_cur)
+  rx824_restart:
 .annotate 'line', 4
-    (rx856_rep, rx856_pos, $I10, $P10) = rx856_cur."!mark_fail"(0)
-    lt rx856_pos, -1, rx856_done
-    eq rx856_pos, -1, rx856_fail
+    rx824_cur."!cursor_debug"("NEXT ", "args")
+  rx824_fail:
+    (rx824_rep, rx824_pos, $I10, $P10) = rx824_cur."!mark_fail"(0)
+    lt rx824_pos, -1, rx824_done
+    eq rx824_pos, -1, rx824_fail
     jump $I10
-  rx856_done:
-    rx856_cur."!cursor_fail"()
-    rx856_cur."!cursor_debug"("FAIL  ", "args")
-    .return (rx856_cur)
+  rx824_done:
+    rx824_cur."!cursor_fail"()
+    rx824_cur."!cursor_debug"("FAIL  ", "args")
+    .return (rx824_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__args"  :subid("195_1278500537.15927") :method
+.sub "!PREFIX__args"  :subid("195_1279529226.73787") :method
 .annotate 'line', 4
-    $P858 = self."!PREFIX__!subrule"("arglist", "(")
-    new $P859, "ResizablePMCArray"
-    push $P859, $P858
-    .return ($P859)
+    $P826 = self."!PREFIX__!subrule"("arglist", "(")
+    new $P827, "ResizablePMCArray"
+    push $P827, $P826
+    .return ($P827)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "arglist"  :subid("196_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "arglist"  :subid("196_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx862_tgt
-    .local int rx862_pos
-    .local int rx862_off
-    .local int rx862_eos
-    .local int rx862_rep
-    .local pmc rx862_cur
-    (rx862_cur, rx862_pos, rx862_tgt) = self."!cursor_start"()
-    rx862_cur."!cursor_debug"("START ", "arglist")
-    .lex unicode:"$\x{a2}", rx862_cur
-    .local pmc match
-    .lex "$/", match
-    length rx862_eos, rx862_tgt
-    gt rx862_pos, rx862_eos, rx862_done
-    set rx862_off, 0
-    lt rx862_pos, 2, rx862_start
-    sub rx862_off, rx862_pos, 1
-    substr rx862_tgt, rx862_tgt, rx862_off
-  rx862_start:
+    .local string rx830_tgt
+    .local int rx830_pos
+    .local int rx830_off
+    .local int rx830_eos
+    .local int rx830_rep
+    .local pmc rx830_cur
+    (rx830_cur, rx830_pos, rx830_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx830_cur
+    .local pmc match
+    .lex "$/", match
+    length rx830_eos, rx830_tgt
+    gt rx830_pos, rx830_eos, rx830_done
+    set rx830_off, 0
+    lt rx830_pos, 2, rx830_start
+    sub rx830_off, rx830_pos, 1
+    substr rx830_tgt, rx830_tgt, rx830_off
+  rx830_start:
+    eq $I10, 1, rx830_restart
+    rx830_cur."!cursor_debug"("START ", "arglist")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan866_done
-    goto rxscan866_scan
-  rxscan866_loop:
-    ($P10) = rx862_cur."from"()
+    ne $I10, -1, rxscan834_done
+    goto rxscan834_scan
+  rxscan834_loop:
+    ($P10) = rx830_cur."from"()
     inc $P10
-    set rx862_pos, $P10
-    ge rx862_pos, rx862_eos, rxscan866_done
-  rxscan866_scan:
-    set_addr $I10, rxscan866_loop
-    rx862_cur."!mark_push"(0, rx862_pos, $I10)
-  rxscan866_done:
+    set rx830_pos, $P10
+    ge rx830_pos, rx830_eos, rxscan834_done
+  rxscan834_scan:
+    set_addr $I10, rxscan834_loop
+    rx830_cur."!mark_push"(0, rx830_pos, $I10)
+  rxscan834_done:
 .annotate 'line', 397
   # rx subrule "ws" subtype=method negate=
-    rx862_cur."!cursor_pos"(rx862_pos)
-    $P10 = rx862_cur."ws"()
-    unless $P10, rx862_fail
-    rx862_pos = $P10."pos"()
-  alt867_0:
+    rx830_cur."!cursor_pos"(rx830_pos)
+    $P10 = rx830_cur."ws"()
+    unless $P10, rx830_fail
+    rx830_pos = $P10."pos"()
+  alt835_0:
 .annotate 'line', 398
-    set_addr $I10, alt867_1
-    rx862_cur."!mark_push"(0, rx862_pos, $I10)
+    set_addr $I10, alt835_1
+    rx830_cur."!mark_push"(0, rx830_pos, $I10)
 .annotate 'line', 399
   # rx subrule "EXPR" subtype=capture negate=
-    rx862_cur."!cursor_pos"(rx862_pos)
-    $P10 = rx862_cur."EXPR"("f=")
-    unless $P10, rx862_fail
-    rx862_cur."!mark_push"(0, -1, 0, $P10)
+    rx830_cur."!cursor_pos"(rx830_pos)
+    $P10 = rx830_cur."EXPR"("f=")
+    unless $P10, rx830_fail
+    rx830_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("EXPR")
-    rx862_pos = $P10."pos"()
-    goto alt867_end
-  alt867_1:
-  alt867_end:
+    rx830_pos = $P10."pos"()
+    goto alt835_end
+  alt835_1:
+  alt835_end:
 .annotate 'line', 396
   # rx pass
-    rx862_cur."!cursor_pass"(rx862_pos, "arglist")
-    rx862_cur."!cursor_debug"("PASS  ", "arglist", " at pos=", rx862_pos)
-    .return (rx862_cur)
-  rx862_fail:
+    rx830_cur."!cursor_pass"(rx830_pos, "arglist")
+    rx830_cur."!cursor_debug"("PASS  ", "arglist", " at pos=", rx830_pos)
+    .return (rx830_cur)
+  rx830_restart:
 .annotate 'line', 4
-    (rx862_rep, rx862_pos, $I10, $P10) = rx862_cur."!mark_fail"(0)
-    lt rx862_pos, -1, rx862_done
-    eq rx862_pos, -1, rx862_fail
+    rx830_cur."!cursor_debug"("NEXT ", "arglist")
+  rx830_fail:
+    (rx830_rep, rx830_pos, $I10, $P10) = rx830_cur."!mark_fail"(0)
+    lt rx830_pos, -1, rx830_done
+    eq rx830_pos, -1, rx830_fail
     jump $I10
-  rx862_done:
-    rx862_cur."!cursor_fail"()
-    rx862_cur."!cursor_debug"("FAIL  ", "arglist")
-    .return (rx862_cur)
+  rx830_done:
+    rx830_cur."!cursor_fail"()
+    rx830_cur."!cursor_debug"("FAIL  ", "arglist")
+    .return (rx830_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__arglist"  :subid("197_1278500537.15927") :method
+.sub "!PREFIX__arglist"  :subid("197_1279529226.73787") :method
 .annotate 'line', 4
-    $P864 = self."!PREFIX__!subrule"("ws", "")
-    new $P865, "ResizablePMCArray"
-    push $P865, $P864
-    .return ($P865)
+    $P832 = self."!PREFIX__!subrule"("ws", "")
+    new $P833, "ResizablePMCArray"
+    push $P833, $P832
+    .return ($P833)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<value>"  :subid("198_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<value>"  :subid("198_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx869_tgt
-    .local int rx869_pos
-    .local int rx869_off
-    .local int rx869_eos
-    .local int rx869_rep
-    .local pmc rx869_cur
-    (rx869_cur, rx869_pos, rx869_tgt) = self."!cursor_start"()
-    rx869_cur."!cursor_debug"("START ", "term:sym<value>")
-    .lex unicode:"$\x{a2}", rx869_cur
-    .local pmc match
-    .lex "$/", match
-    length rx869_eos, rx869_tgt
-    gt rx869_pos, rx869_eos, rx869_done
-    set rx869_off, 0
-    lt rx869_pos, 2, rx869_start
-    sub rx869_off, rx869_pos, 1
-    substr rx869_tgt, rx869_tgt, rx869_off
-  rx869_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan873_done
-    goto rxscan873_scan
-  rxscan873_loop:
-    ($P10) = rx869_cur."from"()
-    inc $P10
-    set rx869_pos, $P10
-    ge rx869_pos, rx869_eos, rxscan873_done
-  rxscan873_scan:
-    set_addr $I10, rxscan873_loop
-    rx869_cur."!mark_push"(0, rx869_pos, $I10)
-  rxscan873_done:
+    .local string rx837_tgt
+    .local int rx837_pos
+    .local int rx837_off
+    .local int rx837_eos
+    .local int rx837_rep
+    .local pmc rx837_cur
+    (rx837_cur, rx837_pos, rx837_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx837_cur
+    .local pmc match
+    .lex "$/", match
+    length rx837_eos, rx837_tgt
+    gt rx837_pos, rx837_eos, rx837_done
+    set rx837_off, 0
+    lt rx837_pos, 2, rx837_start
+    sub rx837_off, rx837_pos, 1
+    substr rx837_tgt, rx837_tgt, rx837_off
+  rx837_start:
+    eq $I10, 1, rx837_restart
+    rx837_cur."!cursor_debug"("START ", "term:sym<value>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan841_done
+    goto rxscan841_scan
+  rxscan841_loop:
+    ($P10) = rx837_cur."from"()
+    inc $P10
+    set rx837_pos, $P10
+    ge rx837_pos, rx837_eos, rxscan841_done
+  rxscan841_scan:
+    set_addr $I10, rxscan841_loop
+    rx837_cur."!mark_push"(0, rx837_pos, $I10)
+  rxscan841_done:
 .annotate 'line', 405
   # rx subrule "value" subtype=capture negate=
-    rx869_cur."!cursor_pos"(rx869_pos)
-    $P10 = rx869_cur."value"()
-    unless $P10, rx869_fail
-    rx869_cur."!mark_push"(0, -1, 0, $P10)
+    rx837_cur."!cursor_pos"(rx837_pos)
+    $P10 = rx837_cur."value"()
+    unless $P10, rx837_fail
+    rx837_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("value")
-    rx869_pos = $P10."pos"()
+    rx837_pos = $P10."pos"()
   # rx pass
-    rx869_cur."!cursor_pass"(rx869_pos, "term:sym<value>")
-    rx869_cur."!cursor_debug"("PASS  ", "term:sym<value>", " at pos=", rx869_pos)
-    .return (rx869_cur)
-  rx869_fail:
+    rx837_cur."!cursor_pass"(rx837_pos, "term:sym<value>")
+    rx837_cur."!cursor_debug"("PASS  ", "term:sym<value>", " at pos=", rx837_pos)
+    .return (rx837_cur)
+  rx837_restart:
 .annotate 'line', 4
-    (rx869_rep, rx869_pos, $I10, $P10) = rx869_cur."!mark_fail"(0)
-    lt rx869_pos, -1, rx869_done
-    eq rx869_pos, -1, rx869_fail
+    rx837_cur."!cursor_debug"("NEXT ", "term:sym<value>")
+  rx837_fail:
+    (rx837_rep, rx837_pos, $I10, $P10) = rx837_cur."!mark_fail"(0)
+    lt rx837_pos, -1, rx837_done
+    eq rx837_pos, -1, rx837_fail
     jump $I10
-  rx869_done:
-    rx869_cur."!cursor_fail"()
-    rx869_cur."!cursor_debug"("FAIL  ", "term:sym<value>")
-    .return (rx869_cur)
+  rx837_done:
+    rx837_cur."!cursor_fail"()
+    rx837_cur."!cursor_debug"("FAIL  ", "term:sym<value>")
+    .return (rx837_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<value>"  :subid("199_1278500537.15927") :method
+.sub "!PREFIX__term:sym<value>"  :subid("199_1279529226.73787") :method
 .annotate 'line', 4
-    $P871 = self."!PREFIX__!subrule"("value", "")
-    new $P872, "ResizablePMCArray"
-    push $P872, $P871
-    .return ($P872)
+    $P839 = self."!PREFIX__!subrule"("value", "")
+    new $P840, "ResizablePMCArray"
+    push $P840, $P839
+    .return ($P840)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "value"  :subid("200_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "value"  :subid("200_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx875_tgt
-    .local int rx875_pos
-    .local int rx875_off
-    .local int rx875_eos
-    .local int rx875_rep
-    .local pmc rx875_cur
-    (rx875_cur, rx875_pos, rx875_tgt) = self."!cursor_start"()
-    rx875_cur."!cursor_debug"("START ", "value")
-    .lex unicode:"$\x{a2}", rx875_cur
+    .local string rx843_tgt
+    .local int rx843_pos
+    .local int rx843_off
+    .local int rx843_eos
+    .local int rx843_rep
+    .local pmc rx843_cur
+    (rx843_cur, rx843_pos, rx843_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx843_cur
     .local pmc match
     .lex "$/", match
-    length rx875_eos, rx875_tgt
-    gt rx875_pos, rx875_eos, rx875_done
-    set rx875_off, 0
-    lt rx875_pos, 2, rx875_start
-    sub rx875_off, rx875_pos, 1
-    substr rx875_tgt, rx875_tgt, rx875_off
-  rx875_start:
+    length rx843_eos, rx843_tgt
+    gt rx843_pos, rx843_eos, rx843_done
+    set rx843_off, 0
+    lt rx843_pos, 2, rx843_start
+    sub rx843_off, rx843_pos, 1
+    substr rx843_tgt, rx843_tgt, rx843_off
+  rx843_start:
+    eq $I10, 1, rx843_restart
+    rx843_cur."!cursor_debug"("START ", "value")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan880_done
-    goto rxscan880_scan
-  rxscan880_loop:
-    ($P10) = rx875_cur."from"()
+    ne $I10, -1, rxscan848_done
+    goto rxscan848_scan
+  rxscan848_loop:
+    ($P10) = rx843_cur."from"()
     inc $P10
-    set rx875_pos, $P10
-    ge rx875_pos, rx875_eos, rxscan880_done
-  rxscan880_scan:
-    set_addr $I10, rxscan880_loop
-    rx875_cur."!mark_push"(0, rx875_pos, $I10)
-  rxscan880_done:
-  alt881_0:
+    set rx843_pos, $P10
+    ge rx843_pos, rx843_eos, rxscan848_done
+  rxscan848_scan:
+    set_addr $I10, rxscan848_loop
+    rx843_cur."!mark_push"(0, rx843_pos, $I10)
+  rxscan848_done:
+  alt849_0:
 .annotate 'line', 407
-    set_addr $I10, alt881_1
-    rx875_cur."!mark_push"(0, rx875_pos, $I10)
+    set_addr $I10, alt849_1
+    rx843_cur."!mark_push"(0, rx843_pos, $I10)
 .annotate 'line', 408
   # rx subrule "quote" subtype=capture negate=
-    rx875_cur."!cursor_pos"(rx875_pos)
-    $P10 = rx875_cur."quote"()
-    unless $P10, rx875_fail
-    rx875_cur."!mark_push"(0, -1, 0, $P10)
+    rx843_cur."!cursor_pos"(rx843_pos)
+    $P10 = rx843_cur."quote"()
+    unless $P10, rx843_fail
+    rx843_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote")
-    rx875_pos = $P10."pos"()
-    goto alt881_end
-  alt881_1:
+    rx843_pos = $P10."pos"()
+    goto alt849_end
+  alt849_1:
 .annotate 'line', 409
   # rx subrule "number" subtype=capture negate=
-    rx875_cur."!cursor_pos"(rx875_pos)
-    $P10 = rx875_cur."number"()
-    unless $P10, rx875_fail
-    rx875_cur."!mark_push"(0, -1, 0, $P10)
+    rx843_cur."!cursor_pos"(rx843_pos)
+    $P10 = rx843_cur."number"()
+    unless $P10, rx843_fail
+    rx843_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("number")
-    rx875_pos = $P10."pos"()
-  alt881_end:
+    rx843_pos = $P10."pos"()
+  alt849_end:
 .annotate 'line', 407
   # rx pass
-    rx875_cur."!cursor_pass"(rx875_pos, "value")
-    rx875_cur."!cursor_debug"("PASS  ", "value", " at pos=", rx875_pos)
-    .return (rx875_cur)
-  rx875_fail:
+    rx843_cur."!cursor_pass"(rx843_pos, "value")
+    rx843_cur."!cursor_debug"("PASS  ", "value", " at pos=", rx843_pos)
+    .return (rx843_cur)
+  rx843_restart:
 .annotate 'line', 4
-    (rx875_rep, rx875_pos, $I10, $P10) = rx875_cur."!mark_fail"(0)
-    lt rx875_pos, -1, rx875_done
-    eq rx875_pos, -1, rx875_fail
+    rx843_cur."!cursor_debug"("NEXT ", "value")
+  rx843_fail:
+    (rx843_rep, rx843_pos, $I10, $P10) = rx843_cur."!mark_fail"(0)
+    lt rx843_pos, -1, rx843_done
+    eq rx843_pos, -1, rx843_fail
     jump $I10
-  rx875_done:
-    rx875_cur."!cursor_fail"()
-    rx875_cur."!cursor_debug"("FAIL  ", "value")
-    .return (rx875_cur)
+  rx843_done:
+    rx843_cur."!cursor_fail"()
+    rx843_cur."!cursor_debug"("FAIL  ", "value")
+    .return (rx843_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__value"  :subid("201_1278500537.15927") :method
+.sub "!PREFIX__value"  :subid("201_1279529226.73787") :method
 .annotate 'line', 4
-    $P877 = self."!PREFIX__!subrule"("number", "")
-    $P878 = self."!PREFIX__!subrule"("quote", "")
-    new $P879, "ResizablePMCArray"
-    push $P879, $P877
-    push $P879, $P878
-    .return ($P879)
+    $P845 = self."!PREFIX__!subrule"("number", "")
+    $P846 = self."!PREFIX__!subrule"("quote", "")
+    new $P847, "ResizablePMCArray"
+    push $P847, $P845
+    push $P847, $P846
+    .return ($P847)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "number"  :subid("202_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "number"  :subid("202_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx883_tgt
-    .local int rx883_pos
-    .local int rx883_off
-    .local int rx883_eos
-    .local int rx883_rep
-    .local pmc rx883_cur
-    (rx883_cur, rx883_pos, rx883_tgt) = self."!cursor_start"()
-    rx883_cur."!cursor_debug"("START ", "number")
-    .lex unicode:"$\x{a2}", rx883_cur
+    .local string rx851_tgt
+    .local int rx851_pos
+    .local int rx851_off
+    .local int rx851_eos
+    .local int rx851_rep
+    .local pmc rx851_cur
+    (rx851_cur, rx851_pos, rx851_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx851_cur
     .local pmc match
     .lex "$/", match
-    length rx883_eos, rx883_tgt
-    gt rx883_pos, rx883_eos, rx883_done
-    set rx883_off, 0
-    lt rx883_pos, 2, rx883_start
-    sub rx883_off, rx883_pos, 1
-    substr rx883_tgt, rx883_tgt, rx883_off
-  rx883_start:
+    length rx851_eos, rx851_tgt
+    gt rx851_pos, rx851_eos, rx851_done
+    set rx851_off, 0
+    lt rx851_pos, 2, rx851_start
+    sub rx851_off, rx851_pos, 1
+    substr rx851_tgt, rx851_tgt, rx851_off
+  rx851_start:
+    eq $I10, 1, rx851_restart
+    rx851_cur."!cursor_debug"("START ", "number")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan886_done
-    goto rxscan886_scan
-  rxscan886_loop:
-    ($P10) = rx883_cur."from"()
+    ne $I10, -1, rxscan854_done
+    goto rxscan854_scan
+  rxscan854_loop:
+    ($P10) = rx851_cur."from"()
     inc $P10
-    set rx883_pos, $P10
-    ge rx883_pos, rx883_eos, rxscan886_done
-  rxscan886_scan:
-    set_addr $I10, rxscan886_loop
-    rx883_cur."!mark_push"(0, rx883_pos, $I10)
-  rxscan886_done:
+    set rx851_pos, $P10
+    ge rx851_pos, rx851_eos, rxscan854_done
+  rxscan854_scan:
+    set_addr $I10, rxscan854_loop
+    rx851_cur."!mark_push"(0, rx851_pos, $I10)
+  rxscan854_done:
 .annotate 'line', 413
   # rx subcapture "sign"
-    set_addr $I10, rxcap_889_fail
-    rx883_cur."!mark_push"(0, rx883_pos, $I10)
-  # rx rxquantr887 ** 0..1
-    set_addr $I888, rxquantr887_done
-    rx883_cur."!mark_push"(0, rx883_pos, $I888)
-  rxquantr887_loop:
+    set_addr $I10, rxcap_856_fail
+    rx851_cur."!mark_push"(0, rx851_pos, $I10)
+  # rx rxquantr855 ** 0..1
+    set_addr $I10, rxquantr855_done
+    rx851_cur."!mark_push"(0, rx851_pos, $I10)
+  rxquantr855_loop:
   # rx enumcharlist negate=0 
-    ge rx883_pos, rx883_eos, rx883_fail
-    sub $I10, rx883_pos, rx883_off
-    substr $S10, rx883_tgt, $I10, 1
+    ge rx851_pos, rx851_eos, rx851_fail
+    sub $I10, rx851_pos, rx851_off
+    substr $S10, rx851_tgt, $I10, 1
     index $I11, "+-", $S10
-    lt $I11, 0, rx883_fail
-    inc rx883_pos
-    (rx883_rep) = rx883_cur."!mark_commit"($I888)
-  rxquantr887_done:
-    set_addr $I10, rxcap_889_fail
-    ($I12, $I11) = rx883_cur."!mark_peek"($I10)
-    rx883_cur."!cursor_pos"($I11)
-    ($P10) = rx883_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx883_pos, "")
-    rx883_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx851_fail
+    inc rx851_pos
+    set_addr $I10, rxquantr855_done
+    (rx851_rep) = rx851_cur."!mark_commit"($I10)
+  rxquantr855_done:
+    set_addr $I10, rxcap_856_fail
+    ($I12, $I11) = rx851_cur."!mark_peek"($I10)
+    rx851_cur."!cursor_pos"($I11)
+    ($P10) = rx851_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx851_pos, "")
+    rx851_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sign")
-    goto rxcap_889_done
-  rxcap_889_fail:
-    goto rx883_fail
-  rxcap_889_done:
-  alt890_0:
+    goto rxcap_856_done
+  rxcap_856_fail:
+    goto rx851_fail
+  rxcap_856_done:
+  alt857_0:
 .annotate 'line', 414
-    set_addr $I10, alt890_1
-    rx883_cur."!mark_push"(0, rx883_pos, $I10)
+    set_addr $I10, alt857_1
+    rx851_cur."!mark_push"(0, rx851_pos, $I10)
   # rx subrule "dec_number" subtype=capture negate=
-    rx883_cur."!cursor_pos"(rx883_pos)
-    $P10 = rx883_cur."dec_number"()
-    unless $P10, rx883_fail
-    rx883_cur."!mark_push"(0, -1, 0, $P10)
+    rx851_cur."!cursor_pos"(rx851_pos)
+    $P10 = rx851_cur."dec_number"()
+    unless $P10, rx851_fail
+    rx851_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("dec_number")
-    rx883_pos = $P10."pos"()
-    goto alt890_end
-  alt890_1:
+    rx851_pos = $P10."pos"()
+    goto alt857_end
+  alt857_1:
   # rx subrule "integer" subtype=capture negate=
-    rx883_cur."!cursor_pos"(rx883_pos)
-    $P10 = rx883_cur."integer"()
-    unless $P10, rx883_fail
-    rx883_cur."!mark_push"(0, -1, 0, $P10)
+    rx851_cur."!cursor_pos"(rx851_pos)
+    $P10 = rx851_cur."integer"()
+    unless $P10, rx851_fail
+    rx851_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("integer")
-    rx883_pos = $P10."pos"()
-  alt890_end:
+    rx851_pos = $P10."pos"()
+  alt857_end:
 .annotate 'line', 412
   # rx pass
-    rx883_cur."!cursor_pass"(rx883_pos, "number")
-    rx883_cur."!cursor_debug"("PASS  ", "number", " at pos=", rx883_pos)
-    .return (rx883_cur)
-  rx883_fail:
+    rx851_cur."!cursor_pass"(rx851_pos, "number")
+    rx851_cur."!cursor_debug"("PASS  ", "number", " at pos=", rx851_pos)
+    .return (rx851_cur)
+  rx851_restart:
 .annotate 'line', 4
-    (rx883_rep, rx883_pos, $I10, $P10) = rx883_cur."!mark_fail"(0)
-    lt rx883_pos, -1, rx883_done
-    eq rx883_pos, -1, rx883_fail
+    rx851_cur."!cursor_debug"("NEXT ", "number")
+  rx851_fail:
+    (rx851_rep, rx851_pos, $I10, $P10) = rx851_cur."!mark_fail"(0)
+    lt rx851_pos, -1, rx851_done
+    eq rx851_pos, -1, rx851_fail
     jump $I10
-  rx883_done:
-    rx883_cur."!cursor_fail"()
-    rx883_cur."!cursor_debug"("FAIL  ", "number")
-    .return (rx883_cur)
+  rx851_done:
+    rx851_cur."!cursor_fail"()
+    rx851_cur."!cursor_debug"("FAIL  ", "number")
+    .return (rx851_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__number"  :subid("203_1278500537.15927") :method
+.sub "!PREFIX__number"  :subid("203_1279529226.73787") :method
 .annotate 'line', 4
-    new $P885, "ResizablePMCArray"
-    push $P885, ""
-    .return ($P885)
+    new $P853, "ResizablePMCArray"
+    push $P853, ""
+    .return ($P853)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote"  :subid("204_1278500537.15927") :method
+.sub "quote"  :subid("204_1279529226.73787") :method
 .annotate 'line', 417
-    $P892 = self."!protoregex"("quote")
-    .return ($P892)
+    $P859 = self."!protoregex"("quote")
+    .return ($P859)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote"  :subid("205_1278500537.15927") :method
+.sub "!PREFIX__quote"  :subid("205_1279529226.73787") :method
 .annotate 'line', 417
-    $P894 = self."!PREFIX__!protoregex"("quote")
-    .return ($P894)
+    $P861 = self."!PREFIX__!protoregex"("quote")
+    .return ($P861)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym<apos>"  :subid("206_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym<apos>"  :subid("206_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx896_tgt
-    .local int rx896_pos
-    .local int rx896_off
-    .local int rx896_eos
-    .local int rx896_rep
-    .local pmc rx896_cur
-    (rx896_cur, rx896_pos, rx896_tgt) = self."!cursor_start"()
-    rx896_cur."!cursor_debug"("START ", "quote:sym<apos>")
-    .lex unicode:"$\x{a2}", rx896_cur
-    .local pmc match
-    .lex "$/", match
-    length rx896_eos, rx896_tgt
-    gt rx896_pos, rx896_eos, rx896_done
-    set rx896_off, 0
-    lt rx896_pos, 2, rx896_start
-    sub rx896_off, rx896_pos, 1
-    substr rx896_tgt, rx896_tgt, rx896_off
-  rx896_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan899_done
-    goto rxscan899_scan
-  rxscan899_loop:
-    ($P10) = rx896_cur."from"()
-    inc $P10
-    set rx896_pos, $P10
-    ge rx896_pos, rx896_eos, rxscan899_done
-  rxscan899_scan:
-    set_addr $I10, rxscan899_loop
-    rx896_cur."!mark_push"(0, rx896_pos, $I10)
-  rxscan899_done:
+    .local string rx863_tgt
+    .local int rx863_pos
+    .local int rx863_off
+    .local int rx863_eos
+    .local int rx863_rep
+    .local pmc rx863_cur
+    (rx863_cur, rx863_pos, rx863_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx863_cur
+    .local pmc match
+    .lex "$/", match
+    length rx863_eos, rx863_tgt
+    gt rx863_pos, rx863_eos, rx863_done
+    set rx863_off, 0
+    lt rx863_pos, 2, rx863_start
+    sub rx863_off, rx863_pos, 1
+    substr rx863_tgt, rx863_tgt, rx863_off
+  rx863_start:
+    eq $I10, 1, rx863_restart
+    rx863_cur."!cursor_debug"("START ", "quote:sym<apos>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan866_done
+    goto rxscan866_scan
+  rxscan866_loop:
+    ($P10) = rx863_cur."from"()
+    inc $P10
+    set rx863_pos, $P10
+    ge rx863_pos, rx863_eos, rxscan866_done
+  rxscan866_scan:
+    set_addr $I10, rxscan866_loop
+    rx863_cur."!mark_push"(0, rx863_pos, $I10)
+  rxscan866_done:
 .annotate 'line', 418
   # rx enumcharlist negate=0 zerowidth
-    ge rx896_pos, rx896_eos, rx896_fail
-    sub $I10, rx896_pos, rx896_off
-    substr $S10, rx896_tgt, $I10, 1
+    ge rx863_pos, rx863_eos, rx863_fail
+    sub $I10, rx863_pos, rx863_off
+    substr $S10, rx863_tgt, $I10, 1
     index $I11, "'", $S10
-    lt $I11, 0, rx896_fail
+    lt $I11, 0, rx863_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx896_cur."!cursor_pos"(rx896_pos)
-    $P10 = rx896_cur."quote_EXPR"(":q")
-    unless $P10, rx896_fail
-    rx896_cur."!mark_push"(0, -1, 0, $P10)
+    rx863_cur."!cursor_pos"(rx863_pos)
+    $P10 = rx863_cur."quote_EXPR"(":q")
+    unless $P10, rx863_fail
+    rx863_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx896_pos = $P10."pos"()
+    rx863_pos = $P10."pos"()
   # rx pass
-    rx896_cur."!cursor_pass"(rx896_pos, "quote:sym<apos>")
-    rx896_cur."!cursor_debug"("PASS  ", "quote:sym<apos>", " at pos=", rx896_pos)
-    .return (rx896_cur)
-  rx896_fail:
+    rx863_cur."!cursor_pass"(rx863_pos, "quote:sym<apos>")
+    rx863_cur."!cursor_debug"("PASS  ", "quote:sym<apos>", " at pos=", rx863_pos)
+    .return (rx863_cur)
+  rx863_restart:
 .annotate 'line', 4
-    (rx896_rep, rx896_pos, $I10, $P10) = rx896_cur."!mark_fail"(0)
-    lt rx896_pos, -1, rx896_done
-    eq rx896_pos, -1, rx896_fail
+    rx863_cur."!cursor_debug"("NEXT ", "quote:sym<apos>")
+  rx863_fail:
+    (rx863_rep, rx863_pos, $I10, $P10) = rx863_cur."!mark_fail"(0)
+    lt rx863_pos, -1, rx863_done
+    eq rx863_pos, -1, rx863_fail
     jump $I10
-  rx896_done:
-    rx896_cur."!cursor_fail"()
-    rx896_cur."!cursor_debug"("FAIL  ", "quote:sym<apos>")
-    .return (rx896_cur)
+  rx863_done:
+    rx863_cur."!cursor_fail"()
+    rx863_cur."!cursor_debug"("FAIL  ", "quote:sym<apos>")
+    .return (rx863_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym<apos>"  :subid("207_1278500537.15927") :method
+.sub "!PREFIX__quote:sym<apos>"  :subid("207_1279529226.73787") :method
 .annotate 'line', 4
-    new $P898, "ResizablePMCArray"
-    push $P898, "'"
-    .return ($P898)
+    new $P865, "ResizablePMCArray"
+    push $P865, "'"
+    .return ($P865)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym<dblq>"  :subid("208_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym<dblq>"  :subid("208_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx901_tgt
-    .local int rx901_pos
-    .local int rx901_off
-    .local int rx901_eos
-    .local int rx901_rep
-    .local pmc rx901_cur
-    (rx901_cur, rx901_pos, rx901_tgt) = self."!cursor_start"()
-    rx901_cur."!cursor_debug"("START ", "quote:sym<dblq>")
-    .lex unicode:"$\x{a2}", rx901_cur
-    .local pmc match
-    .lex "$/", match
-    length rx901_eos, rx901_tgt
-    gt rx901_pos, rx901_eos, rx901_done
-    set rx901_off, 0
-    lt rx901_pos, 2, rx901_start
-    sub rx901_off, rx901_pos, 1
-    substr rx901_tgt, rx901_tgt, rx901_off
-  rx901_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan904_done
-    goto rxscan904_scan
-  rxscan904_loop:
-    ($P10) = rx901_cur."from"()
-    inc $P10
-    set rx901_pos, $P10
-    ge rx901_pos, rx901_eos, rxscan904_done
-  rxscan904_scan:
-    set_addr $I10, rxscan904_loop
-    rx901_cur."!mark_push"(0, rx901_pos, $I10)
-  rxscan904_done:
+    .local string rx868_tgt
+    .local int rx868_pos
+    .local int rx868_off
+    .local int rx868_eos
+    .local int rx868_rep
+    .local pmc rx868_cur
+    (rx868_cur, rx868_pos, rx868_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx868_cur
+    .local pmc match
+    .lex "$/", match
+    length rx868_eos, rx868_tgt
+    gt rx868_pos, rx868_eos, rx868_done
+    set rx868_off, 0
+    lt rx868_pos, 2, rx868_start
+    sub rx868_off, rx868_pos, 1
+    substr rx868_tgt, rx868_tgt, rx868_off
+  rx868_start:
+    eq $I10, 1, rx868_restart
+    rx868_cur."!cursor_debug"("START ", "quote:sym<dblq>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan871_done
+    goto rxscan871_scan
+  rxscan871_loop:
+    ($P10) = rx868_cur."from"()
+    inc $P10
+    set rx868_pos, $P10
+    ge rx868_pos, rx868_eos, rxscan871_done
+  rxscan871_scan:
+    set_addr $I10, rxscan871_loop
+    rx868_cur."!mark_push"(0, rx868_pos, $I10)
+  rxscan871_done:
 .annotate 'line', 419
   # rx enumcharlist negate=0 zerowidth
-    ge rx901_pos, rx901_eos, rx901_fail
-    sub $I10, rx901_pos, rx901_off
-    substr $S10, rx901_tgt, $I10, 1
+    ge rx868_pos, rx868_eos, rx868_fail
+    sub $I10, rx868_pos, rx868_off
+    substr $S10, rx868_tgt, $I10, 1
     index $I11, "\"", $S10
-    lt $I11, 0, rx901_fail
+    lt $I11, 0, rx868_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx901_cur."!cursor_pos"(rx901_pos)
-    $P10 = rx901_cur."quote_EXPR"(":qq")
-    unless $P10, rx901_fail
-    rx901_cur."!mark_push"(0, -1, 0, $P10)
+    rx868_cur."!cursor_pos"(rx868_pos)
+    $P10 = rx868_cur."quote_EXPR"(":qq")
+    unless $P10, rx868_fail
+    rx868_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx901_pos = $P10."pos"()
+    rx868_pos = $P10."pos"()
   # rx pass
-    rx901_cur."!cursor_pass"(rx901_pos, "quote:sym<dblq>")
-    rx901_cur."!cursor_debug"("PASS  ", "quote:sym<dblq>", " at pos=", rx901_pos)
-    .return (rx901_cur)
-  rx901_fail:
+    rx868_cur."!cursor_pass"(rx868_pos, "quote:sym<dblq>")
+    rx868_cur."!cursor_debug"("PASS  ", "quote:sym<dblq>", " at pos=", rx868_pos)
+    .return (rx868_cur)
+  rx868_restart:
 .annotate 'line', 4
-    (rx901_rep, rx901_pos, $I10, $P10) = rx901_cur."!mark_fail"(0)
-    lt rx901_pos, -1, rx901_done
-    eq rx901_pos, -1, rx901_fail
+    rx868_cur."!cursor_debug"("NEXT ", "quote:sym<dblq>")
+  rx868_fail:
+    (rx868_rep, rx868_pos, $I10, $P10) = rx868_cur."!mark_fail"(0)
+    lt rx868_pos, -1, rx868_done
+    eq rx868_pos, -1, rx868_fail
     jump $I10
-  rx901_done:
-    rx901_cur."!cursor_fail"()
-    rx901_cur."!cursor_debug"("FAIL  ", "quote:sym<dblq>")
-    .return (rx901_cur)
+  rx868_done:
+    rx868_cur."!cursor_fail"()
+    rx868_cur."!cursor_debug"("FAIL  ", "quote:sym<dblq>")
+    .return (rx868_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym<dblq>"  :subid("209_1278500537.15927") :method
+.sub "!PREFIX__quote:sym<dblq>"  :subid("209_1279529226.73787") :method
 .annotate 'line', 4
-    new $P903, "ResizablePMCArray"
-    push $P903, "\""
-    .return ($P903)
+    new $P870, "ResizablePMCArray"
+    push $P870, "\""
+    .return ($P870)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym<q>"  :subid("210_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym<q>"  :subid("210_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx906_tgt
-    .local int rx906_pos
-    .local int rx906_off
-    .local int rx906_eos
-    .local int rx906_rep
-    .local pmc rx906_cur
-    (rx906_cur, rx906_pos, rx906_tgt) = self."!cursor_start"()
-    rx906_cur."!cursor_debug"("START ", "quote:sym<q>")
-    .lex unicode:"$\x{a2}", rx906_cur
+    .local string rx873_tgt
+    .local int rx873_pos
+    .local int rx873_off
+    .local int rx873_eos
+    .local int rx873_rep
+    .local pmc rx873_cur
+    (rx873_cur, rx873_pos, rx873_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx873_cur
     .local pmc match
     .lex "$/", match
-    length rx906_eos, rx906_tgt
-    gt rx906_pos, rx906_eos, rx906_done
-    set rx906_off, 0
-    lt rx906_pos, 2, rx906_start
-    sub rx906_off, rx906_pos, 1
-    substr rx906_tgt, rx906_tgt, rx906_off
-  rx906_start:
+    length rx873_eos, rx873_tgt
+    gt rx873_pos, rx873_eos, rx873_done
+    set rx873_off, 0
+    lt rx873_pos, 2, rx873_start
+    sub rx873_off, rx873_pos, 1
+    substr rx873_tgt, rx873_tgt, rx873_off
+  rx873_start:
+    eq $I10, 1, rx873_restart
+    rx873_cur."!cursor_debug"("START ", "quote:sym<q>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan910_done
-    goto rxscan910_scan
-  rxscan910_loop:
-    ($P10) = rx906_cur."from"()
+    ne $I10, -1, rxscan877_done
+    goto rxscan877_scan
+  rxscan877_loop:
+    ($P10) = rx873_cur."from"()
     inc $P10
-    set rx906_pos, $P10
-    ge rx906_pos, rx906_eos, rxscan910_done
-  rxscan910_scan:
-    set_addr $I10, rxscan910_loop
-    rx906_cur."!mark_push"(0, rx906_pos, $I10)
-  rxscan910_done:
+    set rx873_pos, $P10
+    ge rx873_pos, rx873_eos, rxscan877_done
+  rxscan877_scan:
+    set_addr $I10, rxscan877_loop
+    rx873_cur."!mark_push"(0, rx873_pos, $I10)
+  rxscan877_done:
 .annotate 'line', 420
   # rx literal  "q"
-    add $I11, rx906_pos, 1
-    gt $I11, rx906_eos, rx906_fail
-    sub $I11, rx906_pos, rx906_off
-    substr $S10, rx906_tgt, $I11, 1
-    ne $S10, "q", rx906_fail
-    add rx906_pos, 1
+    add $I11, rx873_pos, 1
+    gt $I11, rx873_eos, rx873_fail
+    sub $I11, rx873_pos, rx873_off
+    substr $S10, rx873_tgt, $I11, 1
+    ne $S10, "q", rx873_fail
+    add rx873_pos, 1
   # rxanchor rwb
-    le rx906_pos, 0, rx906_fail
-    sub $I10, rx906_pos, rx906_off
-    is_cclass $I11, 8192, rx906_tgt, $I10
-    if $I11, rx906_fail
+    le rx873_pos, 0, rx873_fail
+    sub $I10, rx873_pos, rx873_off
+    is_cclass $I11, 8192, rx873_tgt, $I10
+    if $I11, rx873_fail
     dec $I10
-    is_cclass $I11, 8192, rx906_tgt, $I10
-    unless $I11, rx906_fail
+    is_cclass $I11, 8192, rx873_tgt, $I10
+    unless $I11, rx873_fail
   # rx enumcharlist negate=1 zerowidth
-    ge rx906_pos, rx906_eos, rx906_fail
-    sub $I10, rx906_pos, rx906_off
-    substr $S10, rx906_tgt, $I10, 1
+    ge rx873_pos, rx873_eos, rx873_fail
+    sub $I10, rx873_pos, rx873_off
+    substr $S10, rx873_tgt, $I10, 1
     index $I11, "(", $S10
-    ge $I11, 0, rx906_fail
+    ge $I11, 0, rx873_fail
   # rx subrule "ws" subtype=method negate=
-    rx906_cur."!cursor_pos"(rx906_pos)
-    $P10 = rx906_cur."ws"()
-    unless $P10, rx906_fail
-    rx906_pos = $P10."pos"()
+    rx873_cur."!cursor_pos"(rx873_pos)
+    $P10 = rx873_cur."ws"()
+    unless $P10, rx873_fail
+    rx873_pos = $P10."pos"()
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx906_cur."!cursor_pos"(rx906_pos)
-    $P10 = rx906_cur."quote_EXPR"(":q")
-    unless $P10, rx906_fail
-    rx906_cur."!mark_push"(0, -1, 0, $P10)
+    rx873_cur."!cursor_pos"(rx873_pos)
+    $P10 = rx873_cur."quote_EXPR"(":q")
+    unless $P10, rx873_fail
+    rx873_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx906_pos = $P10."pos"()
+    rx873_pos = $P10."pos"()
   # rx pass
-    rx906_cur."!cursor_pass"(rx906_pos, "quote:sym<q>")
-    rx906_cur."!cursor_debug"("PASS  ", "quote:sym<q>", " at pos=", rx906_pos)
-    .return (rx906_cur)
-  rx906_fail:
+    rx873_cur."!cursor_pass"(rx873_pos, "quote:sym<q>")
+    rx873_cur."!cursor_debug"("PASS  ", "quote:sym<q>", " at pos=", rx873_pos)
+    .return (rx873_cur)
+  rx873_restart:
 .annotate 'line', 4
-    (rx906_rep, rx906_pos, $I10, $P10) = rx906_cur."!mark_fail"(0)
-    lt rx906_pos, -1, rx906_done
-    eq rx906_pos, -1, rx906_fail
+    rx873_cur."!cursor_debug"("NEXT ", "quote:sym<q>")
+  rx873_fail:
+    (rx873_rep, rx873_pos, $I10, $P10) = rx873_cur."!mark_fail"(0)
+    lt rx873_pos, -1, rx873_done
+    eq rx873_pos, -1, rx873_fail
     jump $I10
-  rx906_done:
-    rx906_cur."!cursor_fail"()
-    rx906_cur."!cursor_debug"("FAIL  ", "quote:sym<q>")
-    .return (rx906_cur)
+  rx873_done:
+    rx873_cur."!cursor_fail"()
+    rx873_cur."!cursor_debug"("FAIL  ", "quote:sym<q>")
+    .return (rx873_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym<q>"  :subid("211_1278500537.15927") :method
+.sub "!PREFIX__quote:sym<q>"  :subid("211_1279529226.73787") :method
 .annotate 'line', 4
-    $P908 = self."!PREFIX__!subrule"("ws", "q")
-    new $P909, "ResizablePMCArray"
-    push $P909, $P908
-    .return ($P909)
+    $P875 = self."!PREFIX__!subrule"("ws", "q")
+    new $P876, "ResizablePMCArray"
+    push $P876, $P875
+    .return ($P876)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym<qq>"  :subid("212_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym<qq>"  :subid("212_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx912_tgt
-    .local int rx912_pos
-    .local int rx912_off
-    .local int rx912_eos
-    .local int rx912_rep
-    .local pmc rx912_cur
-    (rx912_cur, rx912_pos, rx912_tgt) = self."!cursor_start"()
-    rx912_cur."!cursor_debug"("START ", "quote:sym<qq>")
-    .lex unicode:"$\x{a2}", rx912_cur
+    .local string rx879_tgt
+    .local int rx879_pos
+    .local int rx879_off
+    .local int rx879_eos
+    .local int rx879_rep
+    .local pmc rx879_cur
+    (rx879_cur, rx879_pos, rx879_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx879_cur
     .local pmc match
     .lex "$/", match
-    length rx912_eos, rx912_tgt
-    gt rx912_pos, rx912_eos, rx912_done
-    set rx912_off, 0
-    lt rx912_pos, 2, rx912_start
-    sub rx912_off, rx912_pos, 1
-    substr rx912_tgt, rx912_tgt, rx912_off
-  rx912_start:
+    length rx879_eos, rx879_tgt
+    gt rx879_pos, rx879_eos, rx879_done
+    set rx879_off, 0
+    lt rx879_pos, 2, rx879_start
+    sub rx879_off, rx879_pos, 1
+    substr rx879_tgt, rx879_tgt, rx879_off
+  rx879_start:
+    eq $I10, 1, rx879_restart
+    rx879_cur."!cursor_debug"("START ", "quote:sym<qq>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan916_done
-    goto rxscan916_scan
-  rxscan916_loop:
-    ($P10) = rx912_cur."from"()
+    ne $I10, -1, rxscan883_done
+    goto rxscan883_scan
+  rxscan883_loop:
+    ($P10) = rx879_cur."from"()
     inc $P10
-    set rx912_pos, $P10
-    ge rx912_pos, rx912_eos, rxscan916_done
-  rxscan916_scan:
-    set_addr $I10, rxscan916_loop
-    rx912_cur."!mark_push"(0, rx912_pos, $I10)
-  rxscan916_done:
+    set rx879_pos, $P10
+    ge rx879_pos, rx879_eos, rxscan883_done
+  rxscan883_scan:
+    set_addr $I10, rxscan883_loop
+    rx879_cur."!mark_push"(0, rx879_pos, $I10)
+  rxscan883_done:
 .annotate 'line', 421
   # rx literal  "qq"
-    add $I11, rx912_pos, 2
-    gt $I11, rx912_eos, rx912_fail
-    sub $I11, rx912_pos, rx912_off
-    substr $S10, rx912_tgt, $I11, 2
-    ne $S10, "qq", rx912_fail
-    add rx912_pos, 2
+    add $I11, rx879_pos, 2
+    gt $I11, rx879_eos, rx879_fail
+    sub $I11, rx879_pos, rx879_off
+    substr $S10, rx879_tgt, $I11, 2
+    ne $S10, "qq", rx879_fail
+    add rx879_pos, 2
   # rxanchor rwb
-    le rx912_pos, 0, rx912_fail
-    sub $I10, rx912_pos, rx912_off
-    is_cclass $I11, 8192, rx912_tgt, $I10
-    if $I11, rx912_fail
+    le rx879_pos, 0, rx879_fail
+    sub $I10, rx879_pos, rx879_off
+    is_cclass $I11, 8192, rx879_tgt, $I10
+    if $I11, rx879_fail
     dec $I10
-    is_cclass $I11, 8192, rx912_tgt, $I10
-    unless $I11, rx912_fail
+    is_cclass $I11, 8192, rx879_tgt, $I10
+    unless $I11, rx879_fail
   # rx enumcharlist negate=1 zerowidth
-    ge rx912_pos, rx912_eos, rx912_fail
-    sub $I10, rx912_pos, rx912_off
-    substr $S10, rx912_tgt, $I10, 1
+    ge rx879_pos, rx879_eos, rx879_fail
+    sub $I10, rx879_pos, rx879_off
+    substr $S10, rx879_tgt, $I10, 1
     index $I11, "(", $S10
-    ge $I11, 0, rx912_fail
+    ge $I11, 0, rx879_fail
   # rx subrule "ws" subtype=method negate=
-    rx912_cur."!cursor_pos"(rx912_pos)
-    $P10 = rx912_cur."ws"()
-    unless $P10, rx912_fail
-    rx912_pos = $P10."pos"()
+    rx879_cur."!cursor_pos"(rx879_pos)
+    $P10 = rx879_cur."ws"()
+    unless $P10, rx879_fail
+    rx879_pos = $P10."pos"()
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx912_cur."!cursor_pos"(rx912_pos)
-    $P10 = rx912_cur."quote_EXPR"(":qq")
-    unless $P10, rx912_fail
-    rx912_cur."!mark_push"(0, -1, 0, $P10)
+    rx879_cur."!cursor_pos"(rx879_pos)
+    $P10 = rx879_cur."quote_EXPR"(":qq")
+    unless $P10, rx879_fail
+    rx879_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx912_pos = $P10."pos"()
+    rx879_pos = $P10."pos"()
   # rx pass
-    rx912_cur."!cursor_pass"(rx912_pos, "quote:sym<qq>")
-    rx912_cur."!cursor_debug"("PASS  ", "quote:sym<qq>", " at pos=", rx912_pos)
-    .return (rx912_cur)
-  rx912_fail:
+    rx879_cur."!cursor_pass"(rx879_pos, "quote:sym<qq>")
+    rx879_cur."!cursor_debug"("PASS  ", "quote:sym<qq>", " at pos=", rx879_pos)
+    .return (rx879_cur)
+  rx879_restart:
 .annotate 'line', 4
-    (rx912_rep, rx912_pos, $I10, $P10) = rx912_cur."!mark_fail"(0)
-    lt rx912_pos, -1, rx912_done
-    eq rx912_pos, -1, rx912_fail
+    rx879_cur."!cursor_debug"("NEXT ", "quote:sym<qq>")
+  rx879_fail:
+    (rx879_rep, rx879_pos, $I10, $P10) = rx879_cur."!mark_fail"(0)
+    lt rx879_pos, -1, rx879_done
+    eq rx879_pos, -1, rx879_fail
     jump $I10
-  rx912_done:
-    rx912_cur."!cursor_fail"()
-    rx912_cur."!cursor_debug"("FAIL  ", "quote:sym<qq>")
-    .return (rx912_cur)
+  rx879_done:
+    rx879_cur."!cursor_fail"()
+    rx879_cur."!cursor_debug"("FAIL  ", "quote:sym<qq>")
+    .return (rx879_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym<qq>"  :subid("213_1278500537.15927") :method
+.sub "!PREFIX__quote:sym<qq>"  :subid("213_1279529226.73787") :method
 .annotate 'line', 4
-    $P914 = self."!PREFIX__!subrule"("ws", "qq")
-    new $P915, "ResizablePMCArray"
-    push $P915, $P914
-    .return ($P915)
+    $P881 = self."!PREFIX__!subrule"("ws", "qq")
+    new $P882, "ResizablePMCArray"
+    push $P882, $P881
+    .return ($P882)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym<Q>"  :subid("214_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym<Q>"  :subid("214_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx918_tgt
-    .local int rx918_pos
-    .local int rx918_off
-    .local int rx918_eos
-    .local int rx918_rep
-    .local pmc rx918_cur
-    (rx918_cur, rx918_pos, rx918_tgt) = self."!cursor_start"()
-    rx918_cur."!cursor_debug"("START ", "quote:sym<Q>")
-    .lex unicode:"$\x{a2}", rx918_cur
+    .local string rx885_tgt
+    .local int rx885_pos
+    .local int rx885_off
+    .local int rx885_eos
+    .local int rx885_rep
+    .local pmc rx885_cur
+    (rx885_cur, rx885_pos, rx885_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx885_cur
     .local pmc match
     .lex "$/", match
-    length rx918_eos, rx918_tgt
-    gt rx918_pos, rx918_eos, rx918_done
-    set rx918_off, 0
-    lt rx918_pos, 2, rx918_start
-    sub rx918_off, rx918_pos, 1
-    substr rx918_tgt, rx918_tgt, rx918_off
-  rx918_start:
+    length rx885_eos, rx885_tgt
+    gt rx885_pos, rx885_eos, rx885_done
+    set rx885_off, 0
+    lt rx885_pos, 2, rx885_start
+    sub rx885_off, rx885_pos, 1
+    substr rx885_tgt, rx885_tgt, rx885_off
+  rx885_start:
+    eq $I10, 1, rx885_restart
+    rx885_cur."!cursor_debug"("START ", "quote:sym<Q>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan922_done
-    goto rxscan922_scan
-  rxscan922_loop:
-    ($P10) = rx918_cur."from"()
+    ne $I10, -1, rxscan889_done
+    goto rxscan889_scan
+  rxscan889_loop:
+    ($P10) = rx885_cur."from"()
     inc $P10
-    set rx918_pos, $P10
-    ge rx918_pos, rx918_eos, rxscan922_done
-  rxscan922_scan:
-    set_addr $I10, rxscan922_loop
-    rx918_cur."!mark_push"(0, rx918_pos, $I10)
-  rxscan922_done:
+    set rx885_pos, $P10
+    ge rx885_pos, rx885_eos, rxscan889_done
+  rxscan889_scan:
+    set_addr $I10, rxscan889_loop
+    rx885_cur."!mark_push"(0, rx885_pos, $I10)
+  rxscan889_done:
 .annotate 'line', 422
   # rx literal  "Q"
-    add $I11, rx918_pos, 1
-    gt $I11, rx918_eos, rx918_fail
-    sub $I11, rx918_pos, rx918_off
-    substr $S10, rx918_tgt, $I11, 1
-    ne $S10, "Q", rx918_fail
-    add rx918_pos, 1
+    add $I11, rx885_pos, 1
+    gt $I11, rx885_eos, rx885_fail
+    sub $I11, rx885_pos, rx885_off
+    substr $S10, rx885_tgt, $I11, 1
+    ne $S10, "Q", rx885_fail
+    add rx885_pos, 1
   # rxanchor rwb
-    le rx918_pos, 0, rx918_fail
-    sub $I10, rx918_pos, rx918_off
-    is_cclass $I11, 8192, rx918_tgt, $I10
-    if $I11, rx918_fail
+    le rx885_pos, 0, rx885_fail
+    sub $I10, rx885_pos, rx885_off
+    is_cclass $I11, 8192, rx885_tgt, $I10
+    if $I11, rx885_fail
     dec $I10
-    is_cclass $I11, 8192, rx918_tgt, $I10
-    unless $I11, rx918_fail
+    is_cclass $I11, 8192, rx885_tgt, $I10
+    unless $I11, rx885_fail
   # rx enumcharlist negate=1 zerowidth
-    ge rx918_pos, rx918_eos, rx918_fail
-    sub $I10, rx918_pos, rx918_off
-    substr $S10, rx918_tgt, $I10, 1
+    ge rx885_pos, rx885_eos, rx885_fail
+    sub $I10, rx885_pos, rx885_off
+    substr $S10, rx885_tgt, $I10, 1
     index $I11, "(", $S10
-    ge $I11, 0, rx918_fail
+    ge $I11, 0, rx885_fail
   # rx subrule "ws" subtype=method negate=
-    rx918_cur."!cursor_pos"(rx918_pos)
-    $P10 = rx918_cur."ws"()
-    unless $P10, rx918_fail
-    rx918_pos = $P10."pos"()
+    rx885_cur."!cursor_pos"(rx885_pos)
+    $P10 = rx885_cur."ws"()
+    unless $P10, rx885_fail
+    rx885_pos = $P10."pos"()
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx918_cur."!cursor_pos"(rx918_pos)
-    $P10 = rx918_cur."quote_EXPR"()
-    unless $P10, rx918_fail
-    rx918_cur."!mark_push"(0, -1, 0, $P10)
+    rx885_cur."!cursor_pos"(rx885_pos)
+    $P10 = rx885_cur."quote_EXPR"()
+    unless $P10, rx885_fail
+    rx885_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx918_pos = $P10."pos"()
+    rx885_pos = $P10."pos"()
   # rx pass
-    rx918_cur."!cursor_pass"(rx918_pos, "quote:sym<Q>")
-    rx918_cur."!cursor_debug"("PASS  ", "quote:sym<Q>", " at pos=", rx918_pos)
-    .return (rx918_cur)
-  rx918_fail:
+    rx885_cur."!cursor_pass"(rx885_pos, "quote:sym<Q>")
+    rx885_cur."!cursor_debug"("PASS  ", "quote:sym<Q>", " at pos=", rx885_pos)
+    .return (rx885_cur)
+  rx885_restart:
 .annotate 'line', 4
-    (rx918_rep, rx918_pos, $I10, $P10) = rx918_cur."!mark_fail"(0)
-    lt rx918_pos, -1, rx918_done
-    eq rx918_pos, -1, rx918_fail
+    rx885_cur."!cursor_debug"("NEXT ", "quote:sym<Q>")
+  rx885_fail:
+    (rx885_rep, rx885_pos, $I10, $P10) = rx885_cur."!mark_fail"(0)
+    lt rx885_pos, -1, rx885_done
+    eq rx885_pos, -1, rx885_fail
     jump $I10
-  rx918_done:
-    rx918_cur."!cursor_fail"()
-    rx918_cur."!cursor_debug"("FAIL  ", "quote:sym<Q>")
-    .return (rx918_cur)
+  rx885_done:
+    rx885_cur."!cursor_fail"()
+    rx885_cur."!cursor_debug"("FAIL  ", "quote:sym<Q>")
+    .return (rx885_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym<Q>"  :subid("215_1278500537.15927") :method
+.sub "!PREFIX__quote:sym<Q>"  :subid("215_1279529226.73787") :method
 .annotate 'line', 4
-    $P920 = self."!PREFIX__!subrule"("ws", "Q")
-    new $P921, "ResizablePMCArray"
-    push $P921, $P920
-    .return ($P921)
+    $P887 = self."!PREFIX__!subrule"("ws", "Q")
+    new $P888, "ResizablePMCArray"
+    push $P888, $P887
+    .return ($P888)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym<Q:PIR>"  :subid("216_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym<Q:PIR>"  :subid("216_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx924_tgt
-    .local int rx924_pos
-    .local int rx924_off
-    .local int rx924_eos
-    .local int rx924_rep
-    .local pmc rx924_cur
-    (rx924_cur, rx924_pos, rx924_tgt) = self."!cursor_start"()
-    rx924_cur."!cursor_debug"("START ", "quote:sym<Q:PIR>")
-    .lex unicode:"$\x{a2}", rx924_cur
-    .local pmc match
-    .lex "$/", match
-    length rx924_eos, rx924_tgt
-    gt rx924_pos, rx924_eos, rx924_done
-    set rx924_off, 0
-    lt rx924_pos, 2, rx924_start
-    sub rx924_off, rx924_pos, 1
-    substr rx924_tgt, rx924_tgt, rx924_off
-  rx924_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan928_done
-    goto rxscan928_scan
-  rxscan928_loop:
-    ($P10) = rx924_cur."from"()
-    inc $P10
-    set rx924_pos, $P10
-    ge rx924_pos, rx924_eos, rxscan928_done
-  rxscan928_scan:
-    set_addr $I10, rxscan928_loop
-    rx924_cur."!mark_push"(0, rx924_pos, $I10)
-  rxscan928_done:
+    .local string rx891_tgt
+    .local int rx891_pos
+    .local int rx891_off
+    .local int rx891_eos
+    .local int rx891_rep
+    .local pmc rx891_cur
+    (rx891_cur, rx891_pos, rx891_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx891_cur
+    .local pmc match
+    .lex "$/", match
+    length rx891_eos, rx891_tgt
+    gt rx891_pos, rx891_eos, rx891_done
+    set rx891_off, 0
+    lt rx891_pos, 2, rx891_start
+    sub rx891_off, rx891_pos, 1
+    substr rx891_tgt, rx891_tgt, rx891_off
+  rx891_start:
+    eq $I10, 1, rx891_restart
+    rx891_cur."!cursor_debug"("START ", "quote:sym<Q:PIR>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan895_done
+    goto rxscan895_scan
+  rxscan895_loop:
+    ($P10) = rx891_cur."from"()
+    inc $P10
+    set rx891_pos, $P10
+    ge rx891_pos, rx891_eos, rxscan895_done
+  rxscan895_scan:
+    set_addr $I10, rxscan895_loop
+    rx891_cur."!mark_push"(0, rx891_pos, $I10)
+  rxscan895_done:
 .annotate 'line', 423
   # rx literal  "Q:PIR"
-    add $I11, rx924_pos, 5
-    gt $I11, rx924_eos, rx924_fail
-    sub $I11, rx924_pos, rx924_off
-    substr $S10, rx924_tgt, $I11, 5
-    ne $S10, "Q:PIR", rx924_fail
-    add rx924_pos, 5
-  # rx subrule "ws" subtype=method negate=
-    rx924_cur."!cursor_pos"(rx924_pos)
-    $P10 = rx924_cur."ws"()
-    unless $P10, rx924_fail
-    rx924_pos = $P10."pos"()
+    add $I11, rx891_pos, 5
+    gt $I11, rx891_eos, rx891_fail
+    sub $I11, rx891_pos, rx891_off
+    substr $S10, rx891_tgt, $I11, 5
+    ne $S10, "Q:PIR", rx891_fail
+    add rx891_pos, 5
+  # rx subrule "ws" subtype=method negate=
+    rx891_cur."!cursor_pos"(rx891_pos)
+    $P10 = rx891_cur."ws"()
+    unless $P10, rx891_fail
+    rx891_pos = $P10."pos"()
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx924_cur."!cursor_pos"(rx924_pos)
-    $P10 = rx924_cur."quote_EXPR"()
-    unless $P10, rx924_fail
-    rx924_cur."!mark_push"(0, -1, 0, $P10)
+    rx891_cur."!cursor_pos"(rx891_pos)
+    $P10 = rx891_cur."quote_EXPR"()
+    unless $P10, rx891_fail
+    rx891_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx924_pos = $P10."pos"()
+    rx891_pos = $P10."pos"()
   # rx pass
-    rx924_cur."!cursor_pass"(rx924_pos, "quote:sym<Q:PIR>")
-    rx924_cur."!cursor_debug"("PASS  ", "quote:sym<Q:PIR>", " at pos=", rx924_pos)
-    .return (rx924_cur)
-  rx924_fail:
+    rx891_cur."!cursor_pass"(rx891_pos, "quote:sym<Q:PIR>")
+    rx891_cur."!cursor_debug"("PASS  ", "quote:sym<Q:PIR>", " at pos=", rx891_pos)
+    .return (rx891_cur)
+  rx891_restart:
 .annotate 'line', 4
-    (rx924_rep, rx924_pos, $I10, $P10) = rx924_cur."!mark_fail"(0)
-    lt rx924_pos, -1, rx924_done
-    eq rx924_pos, -1, rx924_fail
+    rx891_cur."!cursor_debug"("NEXT ", "quote:sym<Q:PIR>")
+  rx891_fail:
+    (rx891_rep, rx891_pos, $I10, $P10) = rx891_cur."!mark_fail"(0)
+    lt rx891_pos, -1, rx891_done
+    eq rx891_pos, -1, rx891_fail
     jump $I10
-  rx924_done:
-    rx924_cur."!cursor_fail"()
-    rx924_cur."!cursor_debug"("FAIL  ", "quote:sym<Q:PIR>")
-    .return (rx924_cur)
+  rx891_done:
+    rx891_cur."!cursor_fail"()
+    rx891_cur."!cursor_debug"("FAIL  ", "quote:sym<Q:PIR>")
+    .return (rx891_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym<Q:PIR>"  :subid("217_1278500537.15927") :method
+.sub "!PREFIX__quote:sym<Q:PIR>"  :subid("217_1279529226.73787") :method
 .annotate 'line', 4
-    $P926 = self."!PREFIX__!subrule"("ws", "Q:PIR")
-    new $P927, "ResizablePMCArray"
-    push $P927, $P926
-    .return ($P927)
+    $P893 = self."!PREFIX__!subrule"("ws", "Q:PIR")
+    new $P894, "ResizablePMCArray"
+    push $P894, $P893
+    .return ($P894)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote:sym</ />"  :subid("218_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote:sym</ />"  :subid("218_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx930_tgt
-    .local int rx930_pos
-    .local int rx930_off
-    .local int rx930_eos
-    .local int rx930_rep
-    .local pmc rx930_cur
-    (rx930_cur, rx930_pos, rx930_tgt) = self."!cursor_start"()
-    rx930_cur."!cursor_debug"("START ", "quote:sym</ />")
-    .lex unicode:"$\x{a2}", rx930_cur
-    .local pmc match
-    .lex "$/", match
-    length rx930_eos, rx930_tgt
-    gt rx930_pos, rx930_eos, rx930_done
-    set rx930_off, 0
-    lt rx930_pos, 2, rx930_start
-    sub rx930_off, rx930_pos, 1
-    substr rx930_tgt, rx930_tgt, rx930_off
-  rx930_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan934_done
-    goto rxscan934_scan
-  rxscan934_loop:
-    ($P10) = rx930_cur."from"()
-    inc $P10
-    set rx930_pos, $P10
-    ge rx930_pos, rx930_eos, rxscan934_done
-  rxscan934_scan:
-    set_addr $I10, rxscan934_loop
-    rx930_cur."!mark_push"(0, rx930_pos, $I10)
-  rxscan934_done:
+    .local string rx897_tgt
+    .local int rx897_pos
+    .local int rx897_off
+    .local int rx897_eos
+    .local int rx897_rep
+    .local pmc rx897_cur
+    (rx897_cur, rx897_pos, rx897_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx897_cur
+    .local pmc match
+    .lex "$/", match
+    length rx897_eos, rx897_tgt
+    gt rx897_pos, rx897_eos, rx897_done
+    set rx897_off, 0
+    lt rx897_pos, 2, rx897_start
+    sub rx897_off, rx897_pos, 1
+    substr rx897_tgt, rx897_tgt, rx897_off
+  rx897_start:
+    eq $I10, 1, rx897_restart
+    rx897_cur."!cursor_debug"("START ", "quote:sym</ />")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan901_done
+    goto rxscan901_scan
+  rxscan901_loop:
+    ($P10) = rx897_cur."from"()
+    inc $P10
+    set rx897_pos, $P10
+    ge rx897_pos, rx897_eos, rxscan901_done
+  rxscan901_scan:
+    set_addr $I10, rxscan901_loop
+    rx897_cur."!mark_push"(0, rx897_pos, $I10)
+  rxscan901_done:
 .annotate 'line', 425
   # rx literal  "/"
-    add $I11, rx930_pos, 1
-    gt $I11, rx930_eos, rx930_fail
-    sub $I11, rx930_pos, rx930_off
-    substr $S10, rx930_tgt, $I11, 1
-    ne $S10, "/", rx930_fail
-    add rx930_pos, 1
+    add $I11, rx897_pos, 1
+    gt $I11, rx897_eos, rx897_fail
+    sub $I11, rx897_pos, rx897_off
+    substr $S10, rx897_tgt, $I11, 1
+    ne $S10, "/", rx897_fail
+    add rx897_pos, 1
 .annotate 'line', 426
   # rx subrule "newpad" subtype=method negate=
-    rx930_cur."!cursor_pos"(rx930_pos)
-    $P10 = rx930_cur."newpad"()
-    unless $P10, rx930_fail
-    rx930_pos = $P10."pos"()
+    rx897_cur."!cursor_pos"(rx897_pos)
+    $P10 = rx897_cur."newpad"()
+    unless $P10, rx897_fail
+    rx897_pos = $P10."pos"()
 .annotate 'line', 427
   # rx reduce name="quote:sym</ />" key="open"
-    rx930_cur."!cursor_pos"(rx930_pos)
-    rx930_cur."!reduce"("quote:sym</ />", "open")
+    rx897_cur."!cursor_pos"(rx897_pos)
+    rx897_cur."!reduce"("quote:sym</ />", "open")
 .annotate 'line', 428
   # rx subrule "LANG" subtype=capture negate=
-    rx930_cur."!cursor_pos"(rx930_pos)
-    $P10 = rx930_cur."LANG"("Regex", "nibbler")
-    unless $P10, rx930_fail
-    rx930_cur."!mark_push"(0, -1, 0, $P10)
+    rx897_cur."!cursor_pos"(rx897_pos)
+    $P10 = rx897_cur."LANG"("Regex", "nibbler")
+    unless $P10, rx897_fail
+    rx897_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("p6regex")
-    rx930_pos = $P10."pos"()
+    rx897_pos = $P10."pos"()
 .annotate 'line', 429
   # rx literal  "/"
-    add $I11, rx930_pos, 1
-    gt $I11, rx930_eos, rx930_fail
-    sub $I11, rx930_pos, rx930_off
-    substr $S10, rx930_tgt, $I11, 1
-    ne $S10, "/", rx930_fail
-    add rx930_pos, 1
+    add $I11, rx897_pos, 1
+    gt $I11, rx897_eos, rx897_fail
+    sub $I11, rx897_pos, rx897_off
+    substr $S10, rx897_tgt, $I11, 1
+    ne $S10, "/", rx897_fail
+    add rx897_pos, 1
 .annotate 'line', 424
   # rx pass
-    rx930_cur."!cursor_pass"(rx930_pos, "quote:sym</ />")
-    rx930_cur."!cursor_debug"("PASS  ", "quote:sym</ />", " at pos=", rx930_pos)
-    .return (rx930_cur)
-  rx930_fail:
+    rx897_cur."!cursor_pass"(rx897_pos, "quote:sym</ />")
+    rx897_cur."!cursor_debug"("PASS  ", "quote:sym</ />", " at pos=", rx897_pos)
+    .return (rx897_cur)
+  rx897_restart:
 .annotate 'line', 4
-    (rx930_rep, rx930_pos, $I10, $P10) = rx930_cur."!mark_fail"(0)
-    lt rx930_pos, -1, rx930_done
-    eq rx930_pos, -1, rx930_fail
+    rx897_cur."!cursor_debug"("NEXT ", "quote:sym</ />")
+  rx897_fail:
+    (rx897_rep, rx897_pos, $I10, $P10) = rx897_cur."!mark_fail"(0)
+    lt rx897_pos, -1, rx897_done
+    eq rx897_pos, -1, rx897_fail
     jump $I10
-  rx930_done:
-    rx930_cur."!cursor_fail"()
-    rx930_cur."!cursor_debug"("FAIL  ", "quote:sym</ />")
-    .return (rx930_cur)
+  rx897_done:
+    rx897_cur."!cursor_fail"()
+    rx897_cur."!cursor_debug"("FAIL  ", "quote:sym</ />")
+    .return (rx897_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote:sym</ />"  :subid("219_1278500537.15927") :method
+.sub "!PREFIX__quote:sym</ />"  :subid("219_1279529226.73787") :method
 .annotate 'line', 4
-    $P932 = self."!PREFIX__!subrule"("newpad", "/")
-    new $P933, "ResizablePMCArray"
-    push $P933, $P932
-    .return ($P933)
+    $P899 = self."!PREFIX__!subrule"("newpad", "/")
+    new $P900, "ResizablePMCArray"
+    push $P900, $P899
+    .return ($P900)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote_escape:sym<$>"  :subid("220_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote_escape:sym<$>"  :subid("220_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx936_tgt
-    .local int rx936_pos
-    .local int rx936_off
-    .local int rx936_eos
-    .local int rx936_rep
-    .local pmc rx936_cur
-    (rx936_cur, rx936_pos, rx936_tgt) = self."!cursor_start"()
-    rx936_cur."!cursor_debug"("START ", "quote_escape:sym<$>")
-    .lex unicode:"$\x{a2}", rx936_cur
+    .local string rx903_tgt
+    .local int rx903_pos
+    .local int rx903_off
+    .local int rx903_eos
+    .local int rx903_rep
+    .local pmc rx903_cur
+    (rx903_cur, rx903_pos, rx903_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx903_cur
     .local pmc match
     .lex "$/", match
-    length rx936_eos, rx936_tgt
-    gt rx936_pos, rx936_eos, rx936_done
-    set rx936_off, 0
-    lt rx936_pos, 2, rx936_start
-    sub rx936_off, rx936_pos, 1
-    substr rx936_tgt, rx936_tgt, rx936_off
-  rx936_start:
+    length rx903_eos, rx903_tgt
+    gt rx903_pos, rx903_eos, rx903_done
+    set rx903_off, 0
+    lt rx903_pos, 2, rx903_start
+    sub rx903_off, rx903_pos, 1
+    substr rx903_tgt, rx903_tgt, rx903_off
+  rx903_start:
+    eq $I10, 1, rx903_restart
+    rx903_cur."!cursor_debug"("START ", "quote_escape:sym<$>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan939_done
-    goto rxscan939_scan
-  rxscan939_loop:
-    ($P10) = rx936_cur."from"()
+    ne $I10, -1, rxscan906_done
+    goto rxscan906_scan
+  rxscan906_loop:
+    ($P10) = rx903_cur."from"()
     inc $P10
-    set rx936_pos, $P10
-    ge rx936_pos, rx936_eos, rxscan939_done
-  rxscan939_scan:
-    set_addr $I10, rxscan939_loop
-    rx936_cur."!mark_push"(0, rx936_pos, $I10)
-  rxscan939_done:
+    set rx903_pos, $P10
+    ge rx903_pos, rx903_eos, rxscan906_done
+  rxscan906_scan:
+    set_addr $I10, rxscan906_loop
+    rx903_cur."!mark_push"(0, rx903_pos, $I10)
+  rxscan906_done:
 .annotate 'line', 432
   # rx enumcharlist negate=0 zerowidth
-    ge rx936_pos, rx936_eos, rx936_fail
-    sub $I10, rx936_pos, rx936_off
-    substr $S10, rx936_tgt, $I10, 1
+    ge rx903_pos, rx903_eos, rx903_fail
+    sub $I10, rx903_pos, rx903_off
+    substr $S10, rx903_tgt, $I10, 1
     index $I11, "$", $S10
-    lt $I11, 0, rx936_fail
+    lt $I11, 0, rx903_fail
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx936_cur."!cursor_pos"(rx936_pos)
-    $P10 = rx936_cur."quotemod_check"("s")
-    unless $P10, rx936_fail
+    rx903_cur."!cursor_pos"(rx903_pos)
+    $P10 = rx903_cur."quotemod_check"("s")
+    unless $P10, rx903_fail
   # rx subrule "variable" subtype=capture negate=
-    rx936_cur."!cursor_pos"(rx936_pos)
-    $P10 = rx936_cur."variable"()
-    unless $P10, rx936_fail
-    rx936_cur."!mark_push"(0, -1, 0, $P10)
+    rx903_cur."!cursor_pos"(rx903_pos)
+    $P10 = rx903_cur."variable"()
+    unless $P10, rx903_fail
+    rx903_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("variable")
-    rx936_pos = $P10."pos"()
+    rx903_pos = $P10."pos"()
   # rx pass
-    rx936_cur."!cursor_pass"(rx936_pos, "quote_escape:sym<$>")
-    rx936_cur."!cursor_debug"("PASS  ", "quote_escape:sym<$>", " at pos=", rx936_pos)
-    .return (rx936_cur)
-  rx936_fail:
+    rx903_cur."!cursor_pass"(rx903_pos, "quote_escape:sym<$>")
+    rx903_cur."!cursor_debug"("PASS  ", "quote_escape:sym<$>", " at pos=", rx903_pos)
+    .return (rx903_cur)
+  rx903_restart:
 .annotate 'line', 4
-    (rx936_rep, rx936_pos, $I10, $P10) = rx936_cur."!mark_fail"(0)
-    lt rx936_pos, -1, rx936_done
-    eq rx936_pos, -1, rx936_fail
+    rx903_cur."!cursor_debug"("NEXT ", "quote_escape:sym<$>")
+  rx903_fail:
+    (rx903_rep, rx903_pos, $I10, $P10) = rx903_cur."!mark_fail"(0)
+    lt rx903_pos, -1, rx903_done
+    eq rx903_pos, -1, rx903_fail
     jump $I10
-  rx936_done:
-    rx936_cur."!cursor_fail"()
-    rx936_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<$>")
-    .return (rx936_cur)
+  rx903_done:
+    rx903_cur."!cursor_fail"()
+    rx903_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<$>")
+    .return (rx903_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<$>"  :subid("221_1278500537.15927") :method
+.sub "!PREFIX__quote_escape:sym<$>"  :subid("221_1279529226.73787") :method
 .annotate 'line', 4
-    new $P938, "ResizablePMCArray"
-    push $P938, "$"
-    .return ($P938)
+    new $P905, "ResizablePMCArray"
+    push $P905, "$"
+    .return ($P905)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote_escape:sym<{ }>"  :subid("222_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote_escape:sym<{ }>"  :subid("222_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx941_tgt
-    .local int rx941_pos
-    .local int rx941_off
-    .local int rx941_eos
-    .local int rx941_rep
-    .local pmc rx941_cur
-    (rx941_cur, rx941_pos, rx941_tgt) = self."!cursor_start"()
-    rx941_cur."!cursor_debug"("START ", "quote_escape:sym<{ }>")
-    .lex unicode:"$\x{a2}", rx941_cur
+    .local string rx908_tgt
+    .local int rx908_pos
+    .local int rx908_off
+    .local int rx908_eos
+    .local int rx908_rep
+    .local pmc rx908_cur
+    (rx908_cur, rx908_pos, rx908_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx908_cur
     .local pmc match
     .lex "$/", match
-    length rx941_eos, rx941_tgt
-    gt rx941_pos, rx941_eos, rx941_done
-    set rx941_off, 0
-    lt rx941_pos, 2, rx941_start
-    sub rx941_off, rx941_pos, 1
-    substr rx941_tgt, rx941_tgt, rx941_off
-  rx941_start:
+    length rx908_eos, rx908_tgt
+    gt rx908_pos, rx908_eos, rx908_done
+    set rx908_off, 0
+    lt rx908_pos, 2, rx908_start
+    sub rx908_off, rx908_pos, 1
+    substr rx908_tgt, rx908_tgt, rx908_off
+  rx908_start:
+    eq $I10, 1, rx908_restart
+    rx908_cur."!cursor_debug"("START ", "quote_escape:sym<{ }>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan944_done
-    goto rxscan944_scan
-  rxscan944_loop:
-    ($P10) = rx941_cur."from"()
+    ne $I10, -1, rxscan911_done
+    goto rxscan911_scan
+  rxscan911_loop:
+    ($P10) = rx908_cur."from"()
     inc $P10
-    set rx941_pos, $P10
-    ge rx941_pos, rx941_eos, rxscan944_done
-  rxscan944_scan:
-    set_addr $I10, rxscan944_loop
-    rx941_cur."!mark_push"(0, rx941_pos, $I10)
-  rxscan944_done:
+    set rx908_pos, $P10
+    ge rx908_pos, rx908_eos, rxscan911_done
+  rxscan911_scan:
+    set_addr $I10, rxscan911_loop
+    rx908_cur."!mark_push"(0, rx908_pos, $I10)
+  rxscan911_done:
 .annotate 'line', 433
   # rx enumcharlist negate=0 zerowidth
-    ge rx941_pos, rx941_eos, rx941_fail
-    sub $I10, rx941_pos, rx941_off
-    substr $S10, rx941_tgt, $I10, 1
+    ge rx908_pos, rx908_eos, rx908_fail
+    sub $I10, rx908_pos, rx908_off
+    substr $S10, rx908_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx941_fail
+    lt $I11, 0, rx908_fail
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx941_cur."!cursor_pos"(rx941_pos)
-    $P10 = rx941_cur."quotemod_check"("c")
-    unless $P10, rx941_fail
+    rx908_cur."!cursor_pos"(rx908_pos)
+    $P10 = rx908_cur."quotemod_check"("c")
+    unless $P10, rx908_fail
   # rx subrule "block" subtype=capture negate=
-    rx941_cur."!cursor_pos"(rx941_pos)
-    $P10 = rx941_cur."block"()
-    unless $P10, rx941_fail
-    rx941_cur."!mark_push"(0, -1, 0, $P10)
+    rx908_cur."!cursor_pos"(rx908_pos)
+    $P10 = rx908_cur."block"()
+    unless $P10, rx908_fail
+    rx908_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("block")
-    rx941_pos = $P10."pos"()
+    rx908_pos = $P10."pos"()
   # rx pass
-    rx941_cur."!cursor_pass"(rx941_pos, "quote_escape:sym<{ }>")
-    rx941_cur."!cursor_debug"("PASS  ", "quote_escape:sym<{ }>", " at pos=", rx941_pos)
-    .return (rx941_cur)
-  rx941_fail:
+    rx908_cur."!cursor_pass"(rx908_pos, "quote_escape:sym<{ }>")
+    rx908_cur."!cursor_debug"("PASS  ", "quote_escape:sym<{ }>", " at pos=", rx908_pos)
+    .return (rx908_cur)
+  rx908_restart:
 .annotate 'line', 4
-    (rx941_rep, rx941_pos, $I10, $P10) = rx941_cur."!mark_fail"(0)
-    lt rx941_pos, -1, rx941_done
-    eq rx941_pos, -1, rx941_fail
+    rx908_cur."!cursor_debug"("NEXT ", "quote_escape:sym<{ }>")
+  rx908_fail:
+    (rx908_rep, rx908_pos, $I10, $P10) = rx908_cur."!mark_fail"(0)
+    lt rx908_pos, -1, rx908_done
+    eq rx908_pos, -1, rx908_fail
     jump $I10
-  rx941_done:
-    rx941_cur."!cursor_fail"()
-    rx941_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<{ }>")
-    .return (rx941_cur)
+  rx908_done:
+    rx908_cur."!cursor_fail"()
+    rx908_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<{ }>")
+    .return (rx908_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<{ }>"  :subid("223_1278500537.15927") :method
+.sub "!PREFIX__quote_escape:sym<{ }>"  :subid("223_1279529226.73787") :method
 .annotate 'line', 4
-    new $P943, "ResizablePMCArray"
-    push $P943, "{"
-    .return ($P943)
+    new $P910, "ResizablePMCArray"
+    push $P910, "{"
+    .return ($P910)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "quote_escape:sym<esc>"  :subid("224_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "quote_escape:sym<esc>"  :subid("224_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx946_tgt
-    .local int rx946_pos
-    .local int rx946_off
-    .local int rx946_eos
-    .local int rx946_rep
-    .local pmc rx946_cur
-    (rx946_cur, rx946_pos, rx946_tgt) = self."!cursor_start"()
-    rx946_cur."!cursor_debug"("START ", "quote_escape:sym<esc>")
-    .lex unicode:"$\x{a2}", rx946_cur
+    .local string rx913_tgt
+    .local int rx913_pos
+    .local int rx913_off
+    .local int rx913_eos
+    .local int rx913_rep
+    .local pmc rx913_cur
+    (rx913_cur, rx913_pos, rx913_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx913_cur
     .local pmc match
     .lex "$/", match
-    length rx946_eos, rx946_tgt
-    gt rx946_pos, rx946_eos, rx946_done
-    set rx946_off, 0
-    lt rx946_pos, 2, rx946_start
-    sub rx946_off, rx946_pos, 1
-    substr rx946_tgt, rx946_tgt, rx946_off
-  rx946_start:
+    length rx913_eos, rx913_tgt
+    gt rx913_pos, rx913_eos, rx913_done
+    set rx913_off, 0
+    lt rx913_pos, 2, rx913_start
+    sub rx913_off, rx913_pos, 1
+    substr rx913_tgt, rx913_tgt, rx913_off
+  rx913_start:
+    eq $I10, 1, rx913_restart
+    rx913_cur."!cursor_debug"("START ", "quote_escape:sym<esc>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan949_done
-    goto rxscan949_scan
-  rxscan949_loop:
-    ($P10) = rx946_cur."from"()
+    ne $I10, -1, rxscan916_done
+    goto rxscan916_scan
+  rxscan916_loop:
+    ($P10) = rx913_cur."from"()
     inc $P10
-    set rx946_pos, $P10
-    ge rx946_pos, rx946_eos, rxscan949_done
-  rxscan949_scan:
-    set_addr $I10, rxscan949_loop
-    rx946_cur."!mark_push"(0, rx946_pos, $I10)
-  rxscan949_done:
+    set rx913_pos, $P10
+    ge rx913_pos, rx913_eos, rxscan916_done
+  rxscan916_scan:
+    set_addr $I10, rxscan916_loop
+    rx913_cur."!mark_push"(0, rx913_pos, $I10)
+  rxscan916_done:
 .annotate 'line', 434
   # rx literal  "\\e"
-    add $I11, rx946_pos, 2
-    gt $I11, rx946_eos, rx946_fail
-    sub $I11, rx946_pos, rx946_off
-    substr $S10, rx946_tgt, $I11, 2
-    ne $S10, "\\e", rx946_fail
-    add rx946_pos, 2
+    add $I11, rx913_pos, 2
+    gt $I11, rx913_eos, rx913_fail
+    sub $I11, rx913_pos, rx913_off
+    substr $S10, rx913_tgt, $I11, 2
+    ne $S10, "\\e", rx913_fail
+    add rx913_pos, 2
   # rx subrule "quotemod_check" subtype=zerowidth negate=
-    rx946_cur."!cursor_pos"(rx946_pos)
-    $P10 = rx946_cur."quotemod_check"("b")
-    unless $P10, rx946_fail
+    rx913_cur."!cursor_pos"(rx913_pos)
+    $P10 = rx913_cur."quotemod_check"("b")
+    unless $P10, rx913_fail
   # rx pass
-    rx946_cur."!cursor_pass"(rx946_pos, "quote_escape:sym<esc>")
-    rx946_cur."!cursor_debug"("PASS  ", "quote_escape:sym<esc>", " at pos=", rx946_pos)
-    .return (rx946_cur)
-  rx946_fail:
+    rx913_cur."!cursor_pass"(rx913_pos, "quote_escape:sym<esc>")
+    rx913_cur."!cursor_debug"("PASS  ", "quote_escape:sym<esc>", " at pos=", rx913_pos)
+    .return (rx913_cur)
+  rx913_restart:
 .annotate 'line', 4
-    (rx946_rep, rx946_pos, $I10, $P10) = rx946_cur."!mark_fail"(0)
-    lt rx946_pos, -1, rx946_done
-    eq rx946_pos, -1, rx946_fail
+    rx913_cur."!cursor_debug"("NEXT ", "quote_escape:sym<esc>")
+  rx913_fail:
+    (rx913_rep, rx913_pos, $I10, $P10) = rx913_cur."!mark_fail"(0)
+    lt rx913_pos, -1, rx913_done
+    eq rx913_pos, -1, rx913_fail
     jump $I10
-  rx946_done:
-    rx946_cur."!cursor_fail"()
-    rx946_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<esc>")
-    .return (rx946_cur)
+  rx913_done:
+    rx913_cur."!cursor_fail"()
+    rx913_cur."!cursor_debug"("FAIL  ", "quote_escape:sym<esc>")
+    .return (rx913_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__quote_escape:sym<esc>"  :subid("225_1278500537.15927") :method
+.sub "!PREFIX__quote_escape:sym<esc>"  :subid("225_1279529226.73787") :method
 .annotate 'line', 4
-    new $P948, "ResizablePMCArray"
-    push $P948, "\\e"
-    .return ($P948)
+    new $P915, "ResizablePMCArray"
+    push $P915, "\\e"
+    .return ($P915)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "circumfix:sym<( )>"  :subid("226_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "circumfix:sym<( )>"  :subid("226_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx951_tgt
-    .local int rx951_pos
-    .local int rx951_off
-    .local int rx951_eos
-    .local int rx951_rep
-    .local pmc rx951_cur
-    (rx951_cur, rx951_pos, rx951_tgt) = self."!cursor_start"()
-    rx951_cur."!cursor_debug"("START ", "circumfix:sym<( )>")
-    rx951_cur."!cursor_caparray"("EXPR")
-    .lex unicode:"$\x{a2}", rx951_cur
+    .local string rx918_tgt
+    .local int rx918_pos
+    .local int rx918_off
+    .local int rx918_eos
+    .local int rx918_rep
+    .local pmc rx918_cur
+    (rx918_cur, rx918_pos, rx918_tgt, $I10) = self."!cursor_start"()
+    rx918_cur."!cursor_caparray"("EXPR")
+    .lex unicode:"$\x{a2}", rx918_cur
     .local pmc match
     .lex "$/", match
-    length rx951_eos, rx951_tgt
-    gt rx951_pos, rx951_eos, rx951_done
-    set rx951_off, 0
-    lt rx951_pos, 2, rx951_start
-    sub rx951_off, rx951_pos, 1
-    substr rx951_tgt, rx951_tgt, rx951_off
-  rx951_start:
+    length rx918_eos, rx918_tgt
+    gt rx918_pos, rx918_eos, rx918_done
+    set rx918_off, 0
+    lt rx918_pos, 2, rx918_start
+    sub rx918_off, rx918_pos, 1
+    substr rx918_tgt, rx918_tgt, rx918_off
+  rx918_start:
+    eq $I10, 1, rx918_restart
+    rx918_cur."!cursor_debug"("START ", "circumfix:sym<( )>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan955_done
-    goto rxscan955_scan
-  rxscan955_loop:
-    ($P10) = rx951_cur."from"()
+    ne $I10, -1, rxscan922_done
+    goto rxscan922_scan
+  rxscan922_loop:
+    ($P10) = rx918_cur."from"()
     inc $P10
-    set rx951_pos, $P10
-    ge rx951_pos, rx951_eos, rxscan955_done
-  rxscan955_scan:
-    set_addr $I10, rxscan955_loop
-    rx951_cur."!mark_push"(0, rx951_pos, $I10)
-  rxscan955_done:
+    set rx918_pos, $P10
+    ge rx918_pos, rx918_eos, rxscan922_done
+  rxscan922_scan:
+    set_addr $I10, rxscan922_loop
+    rx918_cur."!mark_push"(0, rx918_pos, $I10)
+  rxscan922_done:
 .annotate 'line', 436
   # rx literal  "("
-    add $I11, rx951_pos, 1
-    gt $I11, rx951_eos, rx951_fail
-    sub $I11, rx951_pos, rx951_off
-    substr $S10, rx951_tgt, $I11, 1
-    ne $S10, "(", rx951_fail
-    add rx951_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx951_cur."!cursor_pos"(rx951_pos)
-    $P10 = rx951_cur."ws"()
-    unless $P10, rx951_fail
-    rx951_pos = $P10."pos"()
-  # rx rxquantr956 ** 0..1
-    set_addr $I957, rxquantr956_done
-    rx951_cur."!mark_push"(0, rx951_pos, $I957)
-  rxquantr956_loop:
+    add $I11, rx918_pos, 1
+    gt $I11, rx918_eos, rx918_fail
+    sub $I11, rx918_pos, rx918_off
+    substr $S10, rx918_tgt, $I11, 1
+    ne $S10, "(", rx918_fail
+    add rx918_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx918_cur."!cursor_pos"(rx918_pos)
+    $P10 = rx918_cur."ws"()
+    unless $P10, rx918_fail
+    rx918_pos = $P10."pos"()
+  # rx rxquantr923 ** 0..1
+    set_addr $I10, rxquantr923_done
+    rx918_cur."!mark_push"(0, rx918_pos, $I10)
+  rxquantr923_loop:
   # rx subrule "EXPR" subtype=capture negate=
-    rx951_cur."!cursor_pos"(rx951_pos)
-    $P10 = rx951_cur."EXPR"()
-    unless $P10, rx951_fail
-    rx951_cur."!mark_push"(0, -1, 0, $P10)
+    rx918_cur."!cursor_pos"(rx918_pos)
+    $P10 = rx918_cur."EXPR"()
+    unless $P10, rx918_fail
+    goto rxsubrule924_pass
+  rxsubrule924_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx918_fail
+  rxsubrule924_pass:
+    set_addr $I10, rxsubrule924_back
+    rx918_cur."!mark_push"(0, rx918_pos, $I10, $P10)
     $P10."!cursor_names"("EXPR")
-    rx951_pos = $P10."pos"()
-    (rx951_rep) = rx951_cur."!mark_commit"($I957)
-  rxquantr956_done:
+    rx918_pos = $P10."pos"()
+    set_addr $I10, rxquantr923_done
+    (rx918_rep) = rx918_cur."!mark_commit"($I10)
+  rxquantr923_done:
   # rx literal  ")"
-    add $I11, rx951_pos, 1
-    gt $I11, rx951_eos, rx951_fail
-    sub $I11, rx951_pos, rx951_off
-    substr $S10, rx951_tgt, $I11, 1
-    ne $S10, ")", rx951_fail
-    add rx951_pos, 1
+    add $I11, rx918_pos, 1
+    gt $I11, rx918_eos, rx918_fail
+    sub $I11, rx918_pos, rx918_off
+    substr $S10, rx918_tgt, $I11, 1
+    ne $S10, ")", rx918_fail
+    add rx918_pos, 1
   # rx pass
-    rx951_cur."!cursor_pass"(rx951_pos, "circumfix:sym<( )>")
-    rx951_cur."!cursor_debug"("PASS  ", "circumfix:sym<( )>", " at pos=", rx951_pos)
-    .return (rx951_cur)
-  rx951_fail:
+    rx918_cur."!cursor_pass"(rx918_pos, "circumfix:sym<( )>")
+    rx918_cur."!cursor_debug"("PASS  ", "circumfix:sym<( )>", " at pos=", rx918_pos)
+    .return (rx918_cur)
+  rx918_restart:
 .annotate 'line', 4
-    (rx951_rep, rx951_pos, $I10, $P10) = rx951_cur."!mark_fail"(0)
-    lt rx951_pos, -1, rx951_done
-    eq rx951_pos, -1, rx951_fail
+    rx918_cur."!cursor_debug"("NEXT ", "circumfix:sym<( )>")
+  rx918_fail:
+    (rx918_rep, rx918_pos, $I10, $P10) = rx918_cur."!mark_fail"(0)
+    lt rx918_pos, -1, rx918_done
+    eq rx918_pos, -1, rx918_fail
     jump $I10
-  rx951_done:
-    rx951_cur."!cursor_fail"()
-    rx951_cur."!cursor_debug"("FAIL  ", "circumfix:sym<( )>")
-    .return (rx951_cur)
+  rx918_done:
+    rx918_cur."!cursor_fail"()
+    rx918_cur."!cursor_debug"("FAIL  ", "circumfix:sym<( )>")
+    .return (rx918_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__circumfix:sym<( )>"  :subid("227_1278500537.15927") :method
+.sub "!PREFIX__circumfix:sym<( )>"  :subid("227_1279529226.73787") :method
 .annotate 'line', 4
-    $P953 = self."!PREFIX__!subrule"("ws", "(")
-    new $P954, "ResizablePMCArray"
-    push $P954, $P953
-    .return ($P954)
+    $P920 = self."!PREFIX__!subrule"("ws", "(")
+    new $P921, "ResizablePMCArray"
+    push $P921, $P920
+    .return ($P921)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "circumfix:sym<[ ]>"  :subid("228_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "circumfix:sym<[ ]>"  :subid("228_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx959_tgt
-    .local int rx959_pos
-    .local int rx959_off
-    .local int rx959_eos
-    .local int rx959_rep
-    .local pmc rx959_cur
-    (rx959_cur, rx959_pos, rx959_tgt) = self."!cursor_start"()
-    rx959_cur."!cursor_debug"("START ", "circumfix:sym<[ ]>")
-    rx959_cur."!cursor_caparray"("EXPR")
-    .lex unicode:"$\x{a2}", rx959_cur
-    .local pmc match
-    .lex "$/", match
-    length rx959_eos, rx959_tgt
-    gt rx959_pos, rx959_eos, rx959_done
-    set rx959_off, 0
-    lt rx959_pos, 2, rx959_start
-    sub rx959_off, rx959_pos, 1
-    substr rx959_tgt, rx959_tgt, rx959_off
-  rx959_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan963_done
-    goto rxscan963_scan
-  rxscan963_loop:
-    ($P10) = rx959_cur."from"()
-    inc $P10
-    set rx959_pos, $P10
-    ge rx959_pos, rx959_eos, rxscan963_done
-  rxscan963_scan:
-    set_addr $I10, rxscan963_loop
-    rx959_cur."!mark_push"(0, rx959_pos, $I10)
-  rxscan963_done:
+    .local string rx926_tgt
+    .local int rx926_pos
+    .local int rx926_off
+    .local int rx926_eos
+    .local int rx926_rep
+    .local pmc rx926_cur
+    (rx926_cur, rx926_pos, rx926_tgt, $I10) = self."!cursor_start"()
+    rx926_cur."!cursor_caparray"("EXPR")
+    .lex unicode:"$\x{a2}", rx926_cur
+    .local pmc match
+    .lex "$/", match
+    length rx926_eos, rx926_tgt
+    gt rx926_pos, rx926_eos, rx926_done
+    set rx926_off, 0
+    lt rx926_pos, 2, rx926_start
+    sub rx926_off, rx926_pos, 1
+    substr rx926_tgt, rx926_tgt, rx926_off
+  rx926_start:
+    eq $I10, 1, rx926_restart
+    rx926_cur."!cursor_debug"("START ", "circumfix:sym<[ ]>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan930_done
+    goto rxscan930_scan
+  rxscan930_loop:
+    ($P10) = rx926_cur."from"()
+    inc $P10
+    set rx926_pos, $P10
+    ge rx926_pos, rx926_eos, rxscan930_done
+  rxscan930_scan:
+    set_addr $I10, rxscan930_loop
+    rx926_cur."!mark_push"(0, rx926_pos, $I10)
+  rxscan930_done:
 .annotate 'line', 437
   # rx literal  "["
-    add $I11, rx959_pos, 1
-    gt $I11, rx959_eos, rx959_fail
-    sub $I11, rx959_pos, rx959_off
-    substr $S10, rx959_tgt, $I11, 1
-    ne $S10, "[", rx959_fail
-    add rx959_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx959_cur."!cursor_pos"(rx959_pos)
-    $P10 = rx959_cur."ws"()
-    unless $P10, rx959_fail
-    rx959_pos = $P10."pos"()
-  # rx rxquantr964 ** 0..1
-    set_addr $I965, rxquantr964_done
-    rx959_cur."!mark_push"(0, rx959_pos, $I965)
-  rxquantr964_loop:
+    add $I11, rx926_pos, 1
+    gt $I11, rx926_eos, rx926_fail
+    sub $I11, rx926_pos, rx926_off
+    substr $S10, rx926_tgt, $I11, 1
+    ne $S10, "[", rx926_fail
+    add rx926_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx926_cur."!cursor_pos"(rx926_pos)
+    $P10 = rx926_cur."ws"()
+    unless $P10, rx926_fail
+    rx926_pos = $P10."pos"()
+  # rx rxquantr931 ** 0..1
+    set_addr $I10, rxquantr931_done
+    rx926_cur."!mark_push"(0, rx926_pos, $I10)
+  rxquantr931_loop:
   # rx subrule "EXPR" subtype=capture negate=
-    rx959_cur."!cursor_pos"(rx959_pos)
-    $P10 = rx959_cur."EXPR"()
-    unless $P10, rx959_fail
-    rx959_cur."!mark_push"(0, -1, 0, $P10)
+    rx926_cur."!cursor_pos"(rx926_pos)
+    $P10 = rx926_cur."EXPR"()
+    unless $P10, rx926_fail
+    goto rxsubrule932_pass
+  rxsubrule932_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx926_fail
+  rxsubrule932_pass:
+    set_addr $I10, rxsubrule932_back
+    rx926_cur."!mark_push"(0, rx926_pos, $I10, $P10)
     $P10."!cursor_names"("EXPR")
-    rx959_pos = $P10."pos"()
-    (rx959_rep) = rx959_cur."!mark_commit"($I965)
-  rxquantr964_done:
+    rx926_pos = $P10."pos"()
+    set_addr $I10, rxquantr931_done
+    (rx926_rep) = rx926_cur."!mark_commit"($I10)
+  rxquantr931_done:
   # rx literal  "]"
-    add $I11, rx959_pos, 1
-    gt $I11, rx959_eos, rx959_fail
-    sub $I11, rx959_pos, rx959_off
-    substr $S10, rx959_tgt, $I11, 1
-    ne $S10, "]", rx959_fail
-    add rx959_pos, 1
+    add $I11, rx926_pos, 1
+    gt $I11, rx926_eos, rx926_fail
+    sub $I11, rx926_pos, rx926_off
+    substr $S10, rx926_tgt, $I11, 1
+    ne $S10, "]", rx926_fail
+    add rx926_pos, 1
   # rx pass
-    rx959_cur."!cursor_pass"(rx959_pos, "circumfix:sym<[ ]>")
-    rx959_cur."!cursor_debug"("PASS  ", "circumfix:sym<[ ]>", " at pos=", rx959_pos)
-    .return (rx959_cur)
-  rx959_fail:
+    rx926_cur."!cursor_pass"(rx926_pos, "circumfix:sym<[ ]>")
+    rx926_cur."!cursor_debug"("PASS  ", "circumfix:sym<[ ]>", " at pos=", rx926_pos)
+    .return (rx926_cur)
+  rx926_restart:
 .annotate 'line', 4
-    (rx959_rep, rx959_pos, $I10, $P10) = rx959_cur."!mark_fail"(0)
-    lt rx959_pos, -1, rx959_done
-    eq rx959_pos, -1, rx959_fail
+    rx926_cur."!cursor_debug"("NEXT ", "circumfix:sym<[ ]>")
+  rx926_fail:
+    (rx926_rep, rx926_pos, $I10, $P10) = rx926_cur."!mark_fail"(0)
+    lt rx926_pos, -1, rx926_done
+    eq rx926_pos, -1, rx926_fail
     jump $I10
-  rx959_done:
-    rx959_cur."!cursor_fail"()
-    rx959_cur."!cursor_debug"("FAIL  ", "circumfix:sym<[ ]>")
-    .return (rx959_cur)
+  rx926_done:
+    rx926_cur."!cursor_fail"()
+    rx926_cur."!cursor_debug"("FAIL  ", "circumfix:sym<[ ]>")
+    .return (rx926_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__circumfix:sym<[ ]>"  :subid("229_1278500537.15927") :method
+.sub "!PREFIX__circumfix:sym<[ ]>"  :subid("229_1279529226.73787") :method
 .annotate 'line', 4
-    $P961 = self."!PREFIX__!subrule"("ws", "[")
-    new $P962, "ResizablePMCArray"
-    push $P962, $P961
-    .return ($P962)
+    $P928 = self."!PREFIX__!subrule"("ws", "[")
+    new $P929, "ResizablePMCArray"
+    push $P929, $P928
+    .return ($P929)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "circumfix:sym<ang>"  :subid("230_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "circumfix:sym<ang>"  :subid("230_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx967_tgt
-    .local int rx967_pos
-    .local int rx967_off
-    .local int rx967_eos
-    .local int rx967_rep
-    .local pmc rx967_cur
-    (rx967_cur, rx967_pos, rx967_tgt) = self."!cursor_start"()
-    rx967_cur."!cursor_debug"("START ", "circumfix:sym<ang>")
-    .lex unicode:"$\x{a2}", rx967_cur
+    .local string rx934_tgt
+    .local int rx934_pos
+    .local int rx934_off
+    .local int rx934_eos
+    .local int rx934_rep
+    .local pmc rx934_cur
+    (rx934_cur, rx934_pos, rx934_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx934_cur
     .local pmc match
     .lex "$/", match
-    length rx967_eos, rx967_tgt
-    gt rx967_pos, rx967_eos, rx967_done
-    set rx967_off, 0
-    lt rx967_pos, 2, rx967_start
-    sub rx967_off, rx967_pos, 1
-    substr rx967_tgt, rx967_tgt, rx967_off
-  rx967_start:
+    length rx934_eos, rx934_tgt
+    gt rx934_pos, rx934_eos, rx934_done
+    set rx934_off, 0
+    lt rx934_pos, 2, rx934_start
+    sub rx934_off, rx934_pos, 1
+    substr rx934_tgt, rx934_tgt, rx934_off
+  rx934_start:
+    eq $I10, 1, rx934_restart
+    rx934_cur."!cursor_debug"("START ", "circumfix:sym<ang>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan970_done
-    goto rxscan970_scan
-  rxscan970_loop:
-    ($P10) = rx967_cur."from"()
+    ne $I10, -1, rxscan937_done
+    goto rxscan937_scan
+  rxscan937_loop:
+    ($P10) = rx934_cur."from"()
     inc $P10
-    set rx967_pos, $P10
-    ge rx967_pos, rx967_eos, rxscan970_done
-  rxscan970_scan:
-    set_addr $I10, rxscan970_loop
-    rx967_cur."!mark_push"(0, rx967_pos, $I10)
-  rxscan970_done:
+    set rx934_pos, $P10
+    ge rx934_pos, rx934_eos, rxscan937_done
+  rxscan937_scan:
+    set_addr $I10, rxscan937_loop
+    rx934_cur."!mark_push"(0, rx934_pos, $I10)
+  rxscan937_done:
 .annotate 'line', 438
   # rx enumcharlist negate=0 zerowidth
-    ge rx967_pos, rx967_eos, rx967_fail
-    sub $I10, rx967_pos, rx967_off
-    substr $S10, rx967_tgt, $I10, 1
+    ge rx934_pos, rx934_eos, rx934_fail
+    sub $I10, rx934_pos, rx934_off
+    substr $S10, rx934_tgt, $I10, 1
     index $I11, "<", $S10
-    lt $I11, 0, rx967_fail
+    lt $I11, 0, rx934_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx967_cur."!cursor_pos"(rx967_pos)
-    $P10 = rx967_cur."quote_EXPR"(":q", ":w")
-    unless $P10, rx967_fail
-    rx967_cur."!mark_push"(0, -1, 0, $P10)
+    rx934_cur."!cursor_pos"(rx934_pos)
+    $P10 = rx934_cur."quote_EXPR"(":q", ":w")
+    unless $P10, rx934_fail
+    rx934_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx967_pos = $P10."pos"()
+    rx934_pos = $P10."pos"()
   # rx pass
-    rx967_cur."!cursor_pass"(rx967_pos, "circumfix:sym<ang>")
-    rx967_cur."!cursor_debug"("PASS  ", "circumfix:sym<ang>", " at pos=", rx967_pos)
-    .return (rx967_cur)
-  rx967_fail:
+    rx934_cur."!cursor_pass"(rx934_pos, "circumfix:sym<ang>")
+    rx934_cur."!cursor_debug"("PASS  ", "circumfix:sym<ang>", " at pos=", rx934_pos)
+    .return (rx934_cur)
+  rx934_restart:
 .annotate 'line', 4
-    (rx967_rep, rx967_pos, $I10, $P10) = rx967_cur."!mark_fail"(0)
-    lt rx967_pos, -1, rx967_done
-    eq rx967_pos, -1, rx967_fail
+    rx934_cur."!cursor_debug"("NEXT ", "circumfix:sym<ang>")
+  rx934_fail:
+    (rx934_rep, rx934_pos, $I10, $P10) = rx934_cur."!mark_fail"(0)
+    lt rx934_pos, -1, rx934_done
+    eq rx934_pos, -1, rx934_fail
     jump $I10
-  rx967_done:
-    rx967_cur."!cursor_fail"()
-    rx967_cur."!cursor_debug"("FAIL  ", "circumfix:sym<ang>")
-    .return (rx967_cur)
+  rx934_done:
+    rx934_cur."!cursor_fail"()
+    rx934_cur."!cursor_debug"("FAIL  ", "circumfix:sym<ang>")
+    .return (rx934_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__circumfix:sym<ang>"  :subid("231_1278500537.15927") :method
+.sub "!PREFIX__circumfix:sym<ang>"  :subid("231_1279529226.73787") :method
 .annotate 'line', 4
-    new $P969, "ResizablePMCArray"
-    push $P969, "<"
-    .return ($P969)
+    new $P936, "ResizablePMCArray"
+    push $P936, "<"
+    .return ($P936)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub unicode:"circumfix:sym<\x{ab} \x{bb}>"  :subid("232_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub unicode:"circumfix:sym<\x{ab} \x{bb}>"  :subid("232_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx972_tgt
-    .local int rx972_pos
-    .local int rx972_off
-    .local int rx972_eos
-    .local int rx972_rep
-    .local pmc rx972_cur
-    (rx972_cur, rx972_pos, rx972_tgt) = self."!cursor_start"()
-    rx972_cur."!cursor_debug"("START ", unicode:"circumfix:sym<\x{ab} \x{bb}>")
-    .lex unicode:"$\x{a2}", rx972_cur
+    .local string rx939_tgt
+    .local int rx939_pos
+    .local int rx939_off
+    .local int rx939_eos
+    .local int rx939_rep
+    .local pmc rx939_cur
+    (rx939_cur, rx939_pos, rx939_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx939_cur
     .local pmc match
     .lex "$/", match
-    length rx972_eos, rx972_tgt
-    gt rx972_pos, rx972_eos, rx972_done
-    set rx972_off, 0
-    lt rx972_pos, 2, rx972_start
-    sub rx972_off, rx972_pos, 1
-    substr rx972_tgt, rx972_tgt, rx972_off
-  rx972_start:
+    length rx939_eos, rx939_tgt
+    gt rx939_pos, rx939_eos, rx939_done
+    set rx939_off, 0
+    lt rx939_pos, 2, rx939_start
+    sub rx939_off, rx939_pos, 1
+    substr rx939_tgt, rx939_tgt, rx939_off
+  rx939_start:
+    eq $I10, 1, rx939_restart
+    rx939_cur."!cursor_debug"("START ", unicode:"circumfix:sym<\x{ab} \x{bb}>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan975_done
-    goto rxscan975_scan
-  rxscan975_loop:
-    ($P10) = rx972_cur."from"()
+    ne $I10, -1, rxscan942_done
+    goto rxscan942_scan
+  rxscan942_loop:
+    ($P10) = rx939_cur."from"()
     inc $P10
-    set rx972_pos, $P10
-    ge rx972_pos, rx972_eos, rxscan975_done
-  rxscan975_scan:
-    set_addr $I10, rxscan975_loop
-    rx972_cur."!mark_push"(0, rx972_pos, $I10)
-  rxscan975_done:
+    set rx939_pos, $P10
+    ge rx939_pos, rx939_eos, rxscan942_done
+  rxscan942_scan:
+    set_addr $I10, rxscan942_loop
+    rx939_cur."!mark_push"(0, rx939_pos, $I10)
+  rxscan942_done:
 .annotate 'line', 439
   # rx enumcharlist negate=0 zerowidth
-    ge rx972_pos, rx972_eos, rx972_fail
-    sub $I10, rx972_pos, rx972_off
-    substr $S10, rx972_tgt, $I10, 1
+    ge rx939_pos, rx939_eos, rx939_fail
+    sub $I10, rx939_pos, rx939_off
+    substr $S10, rx939_tgt, $I10, 1
     index $I11, unicode:"\x{ab}", $S10
-    lt $I11, 0, rx972_fail
+    lt $I11, 0, rx939_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx972_cur."!cursor_pos"(rx972_pos)
-    $P10 = rx972_cur."quote_EXPR"(":qq", ":w")
-    unless $P10, rx972_fail
-    rx972_cur."!mark_push"(0, -1, 0, $P10)
+    rx939_cur."!cursor_pos"(rx939_pos)
+    $P10 = rx939_cur."quote_EXPR"(":qq", ":w")
+    unless $P10, rx939_fail
+    rx939_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx972_pos = $P10."pos"()
+    rx939_pos = $P10."pos"()
   # rx pass
-    rx972_cur."!cursor_pass"(rx972_pos, unicode:"circumfix:sym<\x{ab} \x{bb}>")
-    rx972_cur."!cursor_debug"("PASS  ", unicode:"circumfix:sym<\x{ab} \x{bb}>", " at pos=", rx972_pos)
-    .return (rx972_cur)
-  rx972_fail:
+    rx939_cur."!cursor_pass"(rx939_pos, unicode:"circumfix:sym<\x{ab} \x{bb}>")
+    rx939_cur."!cursor_debug"("PASS  ", unicode:"circumfix:sym<\x{ab} \x{bb}>", " at pos=", rx939_pos)
+    .return (rx939_cur)
+  rx939_restart:
 .annotate 'line', 4
-    (rx972_rep, rx972_pos, $I10, $P10) = rx972_cur."!mark_fail"(0)
-    lt rx972_pos, -1, rx972_done
-    eq rx972_pos, -1, rx972_fail
+    rx939_cur."!cursor_debug"("NEXT ", unicode:"circumfix:sym<\x{ab} \x{bb}>")
+  rx939_fail:
+    (rx939_rep, rx939_pos, $I10, $P10) = rx939_cur."!mark_fail"(0)
+    lt rx939_pos, -1, rx939_done
+    eq rx939_pos, -1, rx939_fail
     jump $I10
-  rx972_done:
-    rx972_cur."!cursor_fail"()
-    rx972_cur."!cursor_debug"("FAIL  ", unicode:"circumfix:sym<\x{ab} \x{bb}>")
-    .return (rx972_cur)
+  rx939_done:
+    rx939_cur."!cursor_fail"()
+    rx939_cur."!cursor_debug"("FAIL  ", unicode:"circumfix:sym<\x{ab} \x{bb}>")
+    .return (rx939_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub unicode:"!PREFIX__circumfix:sym<\x{ab} \x{bb}>"  :subid("233_1278500537.15927") :method
+.sub unicode:"!PREFIX__circumfix:sym<\x{ab} \x{bb}>"  :subid("233_1279529226.73787") :method
 .annotate 'line', 4
-    new $P974, "ResizablePMCArray"
-    push $P974, unicode:"\x{ab}"
-    .return ($P974)
+    new $P941, "ResizablePMCArray"
+    push $P941, unicode:"\x{ab}"
+    .return ($P941)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "circumfix:sym<{ }>"  :subid("234_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "circumfix:sym<{ }>"  :subid("234_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx977_tgt
-    .local int rx977_pos
-    .local int rx977_off
-    .local int rx977_eos
-    .local int rx977_rep
-    .local pmc rx977_cur
-    (rx977_cur, rx977_pos, rx977_tgt) = self."!cursor_start"()
-    rx977_cur."!cursor_debug"("START ", "circumfix:sym<{ }>")
-    .lex unicode:"$\x{a2}", rx977_cur
+    .local string rx944_tgt
+    .local int rx944_pos
+    .local int rx944_off
+    .local int rx944_eos
+    .local int rx944_rep
+    .local pmc rx944_cur
+    (rx944_cur, rx944_pos, rx944_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx944_cur
     .local pmc match
     .lex "$/", match
-    length rx977_eos, rx977_tgt
-    gt rx977_pos, rx977_eos, rx977_done
-    set rx977_off, 0
-    lt rx977_pos, 2, rx977_start
-    sub rx977_off, rx977_pos, 1
-    substr rx977_tgt, rx977_tgt, rx977_off
-  rx977_start:
+    length rx944_eos, rx944_tgt
+    gt rx944_pos, rx944_eos, rx944_done
+    set rx944_off, 0
+    lt rx944_pos, 2, rx944_start
+    sub rx944_off, rx944_pos, 1
+    substr rx944_tgt, rx944_tgt, rx944_off
+  rx944_start:
+    eq $I10, 1, rx944_restart
+    rx944_cur."!cursor_debug"("START ", "circumfix:sym<{ }>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan980_done
-    goto rxscan980_scan
-  rxscan980_loop:
-    ($P10) = rx977_cur."from"()
+    ne $I10, -1, rxscan947_done
+    goto rxscan947_scan
+  rxscan947_loop:
+    ($P10) = rx944_cur."from"()
     inc $P10
-    set rx977_pos, $P10
-    ge rx977_pos, rx977_eos, rxscan980_done
-  rxscan980_scan:
-    set_addr $I10, rxscan980_loop
-    rx977_cur."!mark_push"(0, rx977_pos, $I10)
-  rxscan980_done:
+    set rx944_pos, $P10
+    ge rx944_pos, rx944_eos, rxscan947_done
+  rxscan947_scan:
+    set_addr $I10, rxscan947_loop
+    rx944_cur."!mark_push"(0, rx944_pos, $I10)
+  rxscan947_done:
 .annotate 'line', 440
   # rx enumcharlist negate=0 zerowidth
-    ge rx977_pos, rx977_eos, rx977_fail
-    sub $I10, rx977_pos, rx977_off
-    substr $S10, rx977_tgt, $I10, 1
+    ge rx944_pos, rx944_eos, rx944_fail
+    sub $I10, rx944_pos, rx944_off
+    substr $S10, rx944_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx977_fail
+    lt $I11, 0, rx944_fail
   # rx subrule "pblock" subtype=capture negate=
-    rx977_cur."!cursor_pos"(rx977_pos)
-    $P10 = rx977_cur."pblock"()
-    unless $P10, rx977_fail
-    rx977_cur."!mark_push"(0, -1, 0, $P10)
+    rx944_cur."!cursor_pos"(rx944_pos)
+    $P10 = rx944_cur."pblock"()
+    unless $P10, rx944_fail
+    rx944_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("pblock")
-    rx977_pos = $P10."pos"()
+    rx944_pos = $P10."pos"()
   # rx pass
-    rx977_cur."!cursor_pass"(rx977_pos, "circumfix:sym<{ }>")
-    rx977_cur."!cursor_debug"("PASS  ", "circumfix:sym<{ }>", " at pos=", rx977_pos)
-    .return (rx977_cur)
-  rx977_fail:
+    rx944_cur."!cursor_pass"(rx944_pos, "circumfix:sym<{ }>")
+    rx944_cur."!cursor_debug"("PASS  ", "circumfix:sym<{ }>", " at pos=", rx944_pos)
+    .return (rx944_cur)
+  rx944_restart:
 .annotate 'line', 4
-    (rx977_rep, rx977_pos, $I10, $P10) = rx977_cur."!mark_fail"(0)
-    lt rx977_pos, -1, rx977_done
-    eq rx977_pos, -1, rx977_fail
+    rx944_cur."!cursor_debug"("NEXT ", "circumfix:sym<{ }>")
+  rx944_fail:
+    (rx944_rep, rx944_pos, $I10, $P10) = rx944_cur."!mark_fail"(0)
+    lt rx944_pos, -1, rx944_done
+    eq rx944_pos, -1, rx944_fail
     jump $I10
-  rx977_done:
-    rx977_cur."!cursor_fail"()
-    rx977_cur."!cursor_debug"("FAIL  ", "circumfix:sym<{ }>")
-    .return (rx977_cur)
+  rx944_done:
+    rx944_cur."!cursor_fail"()
+    rx944_cur."!cursor_debug"("FAIL  ", "circumfix:sym<{ }>")
+    .return (rx944_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__circumfix:sym<{ }>"  :subid("235_1278500537.15927") :method
+.sub "!PREFIX__circumfix:sym<{ }>"  :subid("235_1279529226.73787") :method
 .annotate 'line', 4
-    new $P979, "ResizablePMCArray"
-    push $P979, "{"
-    .return ($P979)
+    new $P946, "ResizablePMCArray"
+    push $P946, "{"
+    .return ($P946)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "circumfix:sym<sigil>"  :subid("236_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "circumfix:sym<sigil>"  :subid("236_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 4
-    .local string rx982_tgt
-    .local int rx982_pos
-    .local int rx982_off
-    .local int rx982_eos
-    .local int rx982_rep
-    .local pmc rx982_cur
-    (rx982_cur, rx982_pos, rx982_tgt) = self."!cursor_start"()
-    rx982_cur."!cursor_debug"("START ", "circumfix:sym<sigil>")
-    .lex unicode:"$\x{a2}", rx982_cur
+    .local string rx949_tgt
+    .local int rx949_pos
+    .local int rx949_off
+    .local int rx949_eos
+    .local int rx949_rep
+    .local pmc rx949_cur
+    (rx949_cur, rx949_pos, rx949_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx949_cur
     .local pmc match
     .lex "$/", match
-    length rx982_eos, rx982_tgt
-    gt rx982_pos, rx982_eos, rx982_done
-    set rx982_off, 0
-    lt rx982_pos, 2, rx982_start
-    sub rx982_off, rx982_pos, 1
-    substr rx982_tgt, rx982_tgt, rx982_off
-  rx982_start:
+    length rx949_eos, rx949_tgt
+    gt rx949_pos, rx949_eos, rx949_done
+    set rx949_off, 0
+    lt rx949_pos, 2, rx949_start
+    sub rx949_off, rx949_pos, 1
+    substr rx949_tgt, rx949_tgt, rx949_off
+  rx949_start:
+    eq $I10, 1, rx949_restart
+    rx949_cur."!cursor_debug"("START ", "circumfix:sym<sigil>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan986_done
-    goto rxscan986_scan
-  rxscan986_loop:
-    ($P10) = rx982_cur."from"()
+    ne $I10, -1, rxscan953_done
+    goto rxscan953_scan
+  rxscan953_loop:
+    ($P10) = rx949_cur."from"()
     inc $P10
-    set rx982_pos, $P10
-    ge rx982_pos, rx982_eos, rxscan986_done
-  rxscan986_scan:
-    set_addr $I10, rxscan986_loop
-    rx982_cur."!mark_push"(0, rx982_pos, $I10)
-  rxscan986_done:
+    set rx949_pos, $P10
+    ge rx949_pos, rx949_eos, rxscan953_done
+  rxscan953_scan:
+    set_addr $I10, rxscan953_loop
+    rx949_cur."!mark_push"(0, rx949_pos, $I10)
+  rxscan953_done:
 .annotate 'line', 441
   # rx subrule "sigil" subtype=capture negate=
-    rx982_cur."!cursor_pos"(rx982_pos)
-    $P10 = rx982_cur."sigil"()
-    unless $P10, rx982_fail
-    rx982_cur."!mark_push"(0, -1, 0, $P10)
+    rx949_cur."!cursor_pos"(rx949_pos)
+    $P10 = rx949_cur."sigil"()
+    unless $P10, rx949_fail
+    rx949_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sigil")
-    rx982_pos = $P10."pos"()
+    rx949_pos = $P10."pos"()
   # rx literal  "("
-    add $I11, rx982_pos, 1
-    gt $I11, rx982_eos, rx982_fail
-    sub $I11, rx982_pos, rx982_off
-    substr $S10, rx982_tgt, $I11, 1
-    ne $S10, "(", rx982_fail
-    add rx982_pos, 1
+    add $I11, rx949_pos, 1
+    gt $I11, rx949_eos, rx949_fail
+    sub $I11, rx949_pos, rx949_off
+    substr $S10, rx949_tgt, $I11, 1
+    ne $S10, "(", rx949_fail
+    add rx949_pos, 1
   # rx subrule "semilist" subtype=capture negate=
-    rx982_cur."!cursor_pos"(rx982_pos)
-    $P10 = rx982_cur."semilist"()
-    unless $P10, rx982_fail
-    rx982_cur."!mark_push"(0, -1, 0, $P10)
+    rx949_cur."!cursor_pos"(rx949_pos)
+    $P10 = rx949_cur."semilist"()
+    unless $P10, rx949_fail
+    rx949_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("semilist")
-    rx982_pos = $P10."pos"()
-  alt987_0:
-    set_addr $I10, alt987_1
-    rx982_cur."!mark_push"(0, rx982_pos, $I10)
+    rx949_pos = $P10."pos"()
+  alt954_0:
+    set_addr $I10, alt954_1
+    rx949_cur."!mark_push"(0, rx949_pos, $I10)
   # rx literal  ")"
-    add $I11, rx982_pos, 1
-    gt $I11, rx982_eos, rx982_fail
-    sub $I11, rx982_pos, rx982_off
-    substr $S10, rx982_tgt, $I11, 1
-    ne $S10, ")", rx982_fail
-    add rx982_pos, 1
-    goto alt987_end
-  alt987_1:
+    add $I11, rx949_pos, 1
+    gt $I11, rx949_eos, rx949_fail
+    sub $I11, rx949_pos, rx949_off
+    substr $S10, rx949_tgt, $I11, 1
+    ne $S10, ")", rx949_fail
+    add rx949_pos, 1
+    goto alt954_end
+  alt954_1:
   # rx subrule "FAILGOAL" subtype=method negate=
-    rx982_cur."!cursor_pos"(rx982_pos)
-    $P10 = rx982_cur."FAILGOAL"("')'")
-    unless $P10, rx982_fail
-    rx982_pos = $P10."pos"()
-  alt987_end:
-  # rx pass
-    rx982_cur."!cursor_pass"(rx982_pos, "circumfix:sym<sigil>")
-    rx982_cur."!cursor_debug"("PASS  ", "circumfix:sym<sigil>", " at pos=", rx982_pos)
-    .return (rx982_cur)
-  rx982_fail:
-.annotate 'line', 4
-    (rx982_rep, rx982_pos, $I10, $P10) = rx982_cur."!mark_fail"(0)
-    lt rx982_pos, -1, rx982_done
-    eq rx982_pos, -1, rx982_fail
-    jump $I10
-  rx982_done:
-    rx982_cur."!cursor_fail"()
-    rx982_cur."!cursor_debug"("FAIL  ", "circumfix:sym<sigil>")
-    .return (rx982_cur)
+    rx949_cur."!cursor_pos"(rx949_pos)
+    $P10 = rx949_cur."FAILGOAL"("')'")
+    unless $P10, rx949_fail
+    goto rxsubrule956_pass
+  rxsubrule956_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx949_fail
+  rxsubrule956_pass:
+    set_addr $I10, rxsubrule956_back
+    rx949_cur."!mark_push"(0, rx949_pos, $I10, $P10)
+    rx949_pos = $P10."pos"()
+  alt954_end:
+  # rx pass
+    rx949_cur."!cursor_pass"(rx949_pos, "circumfix:sym<sigil>")
+    rx949_cur."!cursor_debug"("PASS  ", "circumfix:sym<sigil>", " at pos=", rx949_pos)
+    .return (rx949_cur)
+  rx949_restart:
+.annotate 'line', 4
+    rx949_cur."!cursor_debug"("NEXT ", "circumfix:sym<sigil>")
+  rx949_fail:
+    (rx949_rep, rx949_pos, $I10, $P10) = rx949_cur."!mark_fail"(0)
+    lt rx949_pos, -1, rx949_done
+    eq rx949_pos, -1, rx949_fail
+    jump $I10
+  rx949_done:
+    rx949_cur."!cursor_fail"()
+    rx949_cur."!cursor_debug"("FAIL  ", "circumfix:sym<sigil>")
+    .return (rx949_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__circumfix:sym<sigil>"  :subid("237_1278500537.15927") :method
-.annotate 'line', 4
-    $P984 = self."!PREFIX__!subrule"("sigil", "")
-    new $P985, "ResizablePMCArray"
-    push $P985, $P984
-    .return ($P985)
-.end
-
-
-.namespace ["NQP";"Grammar"]
-.sub "semilist"  :subid("238_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 4
-    .local string rx990_tgt
-    .local int rx990_pos
-    .local int rx990_off
-    .local int rx990_eos
-    .local int rx990_rep
-    .local pmc rx990_cur
-    (rx990_cur, rx990_pos, rx990_tgt) = self."!cursor_start"()
-    rx990_cur."!cursor_debug"("START ", "semilist")
-    .lex unicode:"$\x{a2}", rx990_cur
-    .local pmc match
-    .lex "$/", match
-    length rx990_eos, rx990_tgt
-    gt rx990_pos, rx990_eos, rx990_done
-    set rx990_off, 0
-    lt rx990_pos, 2, rx990_start
-    sub rx990_off, rx990_pos, 1
-    substr rx990_tgt, rx990_tgt, rx990_off
-  rx990_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan994_done
-    goto rxscan994_scan
-  rxscan994_loop:
-    ($P10) = rx990_cur."from"()
-    inc $P10
-    set rx990_pos, $P10
-    ge rx990_pos, rx990_eos, rxscan994_done
-  rxscan994_scan:
-    set_addr $I10, rxscan994_loop
-    rx990_cur."!mark_push"(0, rx990_pos, $I10)
-  rxscan994_done:
+.sub "!PREFIX__circumfix:sym<sigil>"  :subid("237_1279529226.73787") :method
+.annotate 'line', 4
+    $P951 = self."!PREFIX__!subrule"("sigil", "")
+    new $P952, "ResizablePMCArray"
+    push $P952, $P951
+    .return ($P952)
+.end
+
+
+.namespace ["NQP";"Grammar"]
+.sub "semilist"  :subid("238_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 4
+    .local string rx958_tgt
+    .local int rx958_pos
+    .local int rx958_off
+    .local int rx958_eos
+    .local int rx958_rep
+    .local pmc rx958_cur
+    (rx958_cur, rx958_pos, rx958_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx958_cur
+    .local pmc match
+    .lex "$/", match
+    length rx958_eos, rx958_tgt
+    gt rx958_pos, rx958_eos, rx958_done
+    set rx958_off, 0
+    lt rx958_pos, 2, rx958_start
+    sub rx958_off, rx958_pos, 1
+    substr rx958_tgt, rx958_tgt, rx958_off
+  rx958_start:
+    eq $I10, 1, rx958_restart
+    rx958_cur."!cursor_debug"("START ", "semilist")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan962_done
+    goto rxscan962_scan
+  rxscan962_loop:
+    ($P10) = rx958_cur."from"()
+    inc $P10
+    set rx958_pos, $P10
+    ge rx958_pos, rx958_eos, rxscan962_done
+  rxscan962_scan:
+    set_addr $I10, rxscan962_loop
+    rx958_cur."!mark_push"(0, rx958_pos, $I10)
+  rxscan962_done:
 .annotate 'line', 443
   # rx subrule "ws" subtype=method negate=
-    rx990_cur."!cursor_pos"(rx990_pos)
-    $P10 = rx990_cur."ws"()
-    unless $P10, rx990_fail
-    rx990_pos = $P10."pos"()
+    rx958_cur."!cursor_pos"(rx958_pos)
+    $P10 = rx958_cur."ws"()
+    unless $P10, rx958_fail
+    rx958_pos = $P10."pos"()
   # rx subrule "statement" subtype=capture negate=
-    rx990_cur."!cursor_pos"(rx990_pos)
-    $P10 = rx990_cur."statement"()
-    unless $P10, rx990_fail
-    rx990_cur."!mark_push"(0, -1, 0, $P10)
+    rx958_cur."!cursor_pos"(rx958_pos)
+    $P10 = rx958_cur."statement"()
+    unless $P10, rx958_fail
+    rx958_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("statement")
-    rx990_pos = $P10."pos"()
+    rx958_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx990_cur."!cursor_pos"(rx990_pos)
-    $P10 = rx990_cur."ws"()
-    unless $P10, rx990_fail
-    rx990_pos = $P10."pos"()
+    rx958_cur."!cursor_pos"(rx958_pos)
+    $P10 = rx958_cur."ws"()
+    unless $P10, rx958_fail
+    rx958_pos = $P10."pos"()
   # rx pass
-    rx990_cur."!cursor_pass"(rx990_pos, "semilist")
-    rx990_cur."!cursor_debug"("PASS  ", "semilist", " at pos=", rx990_pos)
-    .return (rx990_cur)
-  rx990_fail:
+    rx958_cur."!cursor_pass"(rx958_pos, "semilist")
+    rx958_cur."!cursor_debug"("PASS  ", "semilist", " at pos=", rx958_pos)
+    .return (rx958_cur)
+  rx958_restart:
 .annotate 'line', 4
-    (rx990_rep, rx990_pos, $I10, $P10) = rx990_cur."!mark_fail"(0)
-    lt rx990_pos, -1, rx990_done
-    eq rx990_pos, -1, rx990_fail
+    rx958_cur."!cursor_debug"("NEXT ", "semilist")
+  rx958_fail:
+    (rx958_rep, rx958_pos, $I10, $P10) = rx958_cur."!mark_fail"(0)
+    lt rx958_pos, -1, rx958_done
+    eq rx958_pos, -1, rx958_fail
     jump $I10
-  rx990_done:
-    rx990_cur."!cursor_fail"()
-    rx990_cur."!cursor_debug"("FAIL  ", "semilist")
-    .return (rx990_cur)
+  rx958_done:
+    rx958_cur."!cursor_fail"()
+    rx958_cur."!cursor_debug"("FAIL  ", "semilist")
+    .return (rx958_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__semilist"  :subid("239_1278500537.15927") :method
+.sub "!PREFIX__semilist"  :subid("239_1279529226.73787") :method
 .annotate 'line', 4
-    $P992 = self."!PREFIX__!subrule"("ws", "")
-    new $P993, "ResizablePMCArray"
-    push $P993, $P992
-    .return ($P993)
+    $P960 = self."!PREFIX__!subrule"("ws", "")
+    new $P961, "ResizablePMCArray"
+    push $P961, $P960
+    .return ($P961)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infixish"  :subid("240_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infixish"  :subid("240_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx998_tgt
-    .local int rx998_pos
-    .local int rx998_off
-    .local int rx998_eos
-    .local int rx998_rep
-    .local pmc rx998_cur
-    (rx998_cur, rx998_pos, rx998_tgt) = self."!cursor_start"()
-    rx998_cur."!cursor_debug"("START ", "infixish")
-    .lex unicode:"$\x{a2}", rx998_cur
+    .local string rx966_tgt
+    .local int rx966_pos
+    .local int rx966_off
+    .local int rx966_eos
+    .local int rx966_rep
+    .local pmc rx966_cur
+    (rx966_cur, rx966_pos, rx966_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx966_cur
     .local pmc match
     .lex "$/", match
-    length rx998_eos, rx998_tgt
-    gt rx998_pos, rx998_eos, rx998_done
-    set rx998_off, 0
-    lt rx998_pos, 2, rx998_start
-    sub rx998_off, rx998_pos, 1
-    substr rx998_tgt, rx998_tgt, rx998_off
-  rx998_start:
+    length rx966_eos, rx966_tgt
+    gt rx966_pos, rx966_eos, rx966_done
+    set rx966_off, 0
+    lt rx966_pos, 2, rx966_start
+    sub rx966_off, rx966_pos, 1
+    substr rx966_tgt, rx966_tgt, rx966_off
+  rx966_start:
+    eq $I10, 1, rx966_restart
+    rx966_cur."!cursor_debug"("START ", "infixish")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1001_done
-    goto rxscan1001_scan
-  rxscan1001_loop:
-    ($P10) = rx998_cur."from"()
+    ne $I10, -1, rxscan969_done
+    goto rxscan969_scan
+  rxscan969_loop:
+    ($P10) = rx966_cur."from"()
     inc $P10
-    set rx998_pos, $P10
-    ge rx998_pos, rx998_eos, rxscan1001_done
-  rxscan1001_scan:
-    set_addr $I10, rxscan1001_loop
-    rx998_cur."!mark_push"(0, rx998_pos, $I10)
-  rxscan1001_done:
+    set rx966_pos, $P10
+    ge rx966_pos, rx966_eos, rxscan969_done
+  rxscan969_scan:
+    set_addr $I10, rxscan969_loop
+    rx966_cur."!mark_push"(0, rx966_pos, $I10)
+  rxscan969_done:
 .annotate 'line', 466
   # rx subrule "infixstopper" subtype=zerowidth negate=1
-    rx998_cur."!cursor_pos"(rx998_pos)
-    $P10 = rx998_cur."infixstopper"()
-    if $P10, rx998_fail
+    rx966_cur."!cursor_pos"(rx966_pos)
+    $P10 = rx966_cur."infixstopper"()
+    if $P10, rx966_fail
   # rx subrule "infix" subtype=capture negate=
-    rx998_cur."!cursor_pos"(rx998_pos)
-    $P10 = rx998_cur."infix"()
-    unless $P10, rx998_fail
-    rx998_cur."!mark_push"(0, -1, 0, $P10)
+    rx966_cur."!cursor_pos"(rx966_pos)
+    $P10 = rx966_cur."infix"()
+    unless $P10, rx966_fail
+    rx966_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("OPER=infix")
-    rx998_pos = $P10."pos"()
+    rx966_pos = $P10."pos"()
   # rx pass
-    rx998_cur."!cursor_pass"(rx998_pos, "infixish")
-    rx998_cur."!cursor_debug"("PASS  ", "infixish", " at pos=", rx998_pos)
-    .return (rx998_cur)
-  rx998_fail:
+    rx966_cur."!cursor_pass"(rx966_pos, "infixish")
+    rx966_cur."!cursor_debug"("PASS  ", "infixish", " at pos=", rx966_pos)
+    .return (rx966_cur)
+  rx966_restart:
 .annotate 'line', 447
-    (rx998_rep, rx998_pos, $I10, $P10) = rx998_cur."!mark_fail"(0)
-    lt rx998_pos, -1, rx998_done
-    eq rx998_pos, -1, rx998_fail
+    rx966_cur."!cursor_debug"("NEXT ", "infixish")
+  rx966_fail:
+    (rx966_rep, rx966_pos, $I10, $P10) = rx966_cur."!mark_fail"(0)
+    lt rx966_pos, -1, rx966_done
+    eq rx966_pos, -1, rx966_fail
     jump $I10
-  rx998_done:
-    rx998_cur."!cursor_fail"()
-    rx998_cur."!cursor_debug"("FAIL  ", "infixish")
-    .return (rx998_cur)
+  rx966_done:
+    rx966_cur."!cursor_fail"()
+    rx966_cur."!cursor_debug"("FAIL  ", "infixish")
+    .return (rx966_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infixish"  :subid("241_1278500537.15927") :method
+.sub "!PREFIX__infixish"  :subid("241_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1000, "ResizablePMCArray"
-    push $P1000, ""
-    .return ($P1000)
+    new $P968, "ResizablePMCArray"
+    push $P968, ""
+    .return ($P968)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infixstopper"  :subid("242_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infixstopper"  :subid("242_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1003_tgt
-    .local int rx1003_pos
-    .local int rx1003_off
-    .local int rx1003_eos
-    .local int rx1003_rep
-    .local pmc rx1003_cur
-    (rx1003_cur, rx1003_pos, rx1003_tgt) = self."!cursor_start"()
-    rx1003_cur."!cursor_debug"("START ", "infixstopper")
-    .lex unicode:"$\x{a2}", rx1003_cur
+    .local string rx971_tgt
+    .local int rx971_pos
+    .local int rx971_off
+    .local int rx971_eos
+    .local int rx971_rep
+    .local pmc rx971_cur
+    (rx971_cur, rx971_pos, rx971_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx971_cur
     .local pmc match
     .lex "$/", match
-    length rx1003_eos, rx1003_tgt
-    gt rx1003_pos, rx1003_eos, rx1003_done
-    set rx1003_off, 0
-    lt rx1003_pos, 2, rx1003_start
-    sub rx1003_off, rx1003_pos, 1
-    substr rx1003_tgt, rx1003_tgt, rx1003_off
-  rx1003_start:
+    length rx971_eos, rx971_tgt
+    gt rx971_pos, rx971_eos, rx971_done
+    set rx971_off, 0
+    lt rx971_pos, 2, rx971_start
+    sub rx971_off, rx971_pos, 1
+    substr rx971_tgt, rx971_tgt, rx971_off
+  rx971_start:
+    eq $I10, 1, rx971_restart
+    rx971_cur."!cursor_debug"("START ", "infixstopper")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1006_done
-    goto rxscan1006_scan
-  rxscan1006_loop:
-    ($P10) = rx1003_cur."from"()
+    ne $I10, -1, rxscan974_done
+    goto rxscan974_scan
+  rxscan974_loop:
+    ($P10) = rx971_cur."from"()
     inc $P10
-    set rx1003_pos, $P10
-    ge rx1003_pos, rx1003_eos, rxscan1006_done
-  rxscan1006_scan:
-    set_addr $I10, rxscan1006_loop
-    rx1003_cur."!mark_push"(0, rx1003_pos, $I10)
-  rxscan1006_done:
+    set rx971_pos, $P10
+    ge rx971_pos, rx971_eos, rxscan974_done
+  rxscan974_scan:
+    set_addr $I10, rxscan974_loop
+    rx971_cur."!mark_push"(0, rx971_pos, $I10)
+  rxscan974_done:
 .annotate 'line', 467
   # rx subrule "lambda" subtype=zerowidth negate=
-    rx1003_cur."!cursor_pos"(rx1003_pos)
-    $P10 = rx1003_cur."lambda"()
-    unless $P10, rx1003_fail
+    rx971_cur."!cursor_pos"(rx971_pos)
+    $P10 = rx971_cur."lambda"()
+    unless $P10, rx971_fail
   # rx pass
-    rx1003_cur."!cursor_pass"(rx1003_pos, "infixstopper")
-    rx1003_cur."!cursor_debug"("PASS  ", "infixstopper", " at pos=", rx1003_pos)
-    .return (rx1003_cur)
-  rx1003_fail:
+    rx971_cur."!cursor_pass"(rx971_pos, "infixstopper")
+    rx971_cur."!cursor_debug"("PASS  ", "infixstopper", " at pos=", rx971_pos)
+    .return (rx971_cur)
+  rx971_restart:
 .annotate 'line', 447
-    (rx1003_rep, rx1003_pos, $I10, $P10) = rx1003_cur."!mark_fail"(0)
-    lt rx1003_pos, -1, rx1003_done
-    eq rx1003_pos, -1, rx1003_fail
+    rx971_cur."!cursor_debug"("NEXT ", "infixstopper")
+  rx971_fail:
+    (rx971_rep, rx971_pos, $I10, $P10) = rx971_cur."!mark_fail"(0)
+    lt rx971_pos, -1, rx971_done
+    eq rx971_pos, -1, rx971_fail
     jump $I10
-  rx1003_done:
-    rx1003_cur."!cursor_fail"()
-    rx1003_cur."!cursor_debug"("FAIL  ", "infixstopper")
-    .return (rx1003_cur)
+  rx971_done:
+    rx971_cur."!cursor_fail"()
+    rx971_cur."!cursor_debug"("FAIL  ", "infixstopper")
+    .return (rx971_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infixstopper"  :subid("243_1278500537.15927") :method
+.sub "!PREFIX__infixstopper"  :subid("243_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1005, "ResizablePMCArray"
-    push $P1005, ""
-    .return ($P1005)
+    new $P973, "ResizablePMCArray"
+    push $P973, ""
+    .return ($P973)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postcircumfix:sym<[ ]>"  :subid("244_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postcircumfix:sym<[ ]>"  :subid("244_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1008_tgt
-    .local int rx1008_pos
-    .local int rx1008_off
-    .local int rx1008_eos
-    .local int rx1008_rep
-    .local pmc rx1008_cur
-    (rx1008_cur, rx1008_pos, rx1008_tgt) = self."!cursor_start"()
-    rx1008_cur."!cursor_debug"("START ", "postcircumfix:sym<[ ]>")
-    .lex unicode:"$\x{a2}", rx1008_cur
+    .local string rx976_tgt
+    .local int rx976_pos
+    .local int rx976_off
+    .local int rx976_eos
+    .local int rx976_rep
+    .local pmc rx976_cur
+    (rx976_cur, rx976_pos, rx976_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx976_cur
     .local pmc match
     .lex "$/", match
-    length rx1008_eos, rx1008_tgt
-    gt rx1008_pos, rx1008_eos, rx1008_done
-    set rx1008_off, 0
-    lt rx1008_pos, 2, rx1008_start
-    sub rx1008_off, rx1008_pos, 1
-    substr rx1008_tgt, rx1008_tgt, rx1008_off
-  rx1008_start:
+    length rx976_eos, rx976_tgt
+    gt rx976_pos, rx976_eos, rx976_done
+    set rx976_off, 0
+    lt rx976_pos, 2, rx976_start
+    sub rx976_off, rx976_pos, 1
+    substr rx976_tgt, rx976_tgt, rx976_off
+  rx976_start:
+    eq $I10, 1, rx976_restart
+    rx976_cur."!cursor_debug"("START ", "postcircumfix:sym<[ ]>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1012_done
-    goto rxscan1012_scan
-  rxscan1012_loop:
-    ($P10) = rx1008_cur."from"()
+    ne $I10, -1, rxscan980_done
+    goto rxscan980_scan
+  rxscan980_loop:
+    ($P10) = rx976_cur."from"()
     inc $P10
-    set rx1008_pos, $P10
-    ge rx1008_pos, rx1008_eos, rxscan1012_done
-  rxscan1012_scan:
-    set_addr $I10, rxscan1012_loop
-    rx1008_cur."!mark_push"(0, rx1008_pos, $I10)
-  rxscan1012_done:
+    set rx976_pos, $P10
+    ge rx976_pos, rx976_eos, rxscan980_done
+  rxscan980_scan:
+    set_addr $I10, rxscan980_loop
+    rx976_cur."!mark_push"(0, rx976_pos, $I10)
+  rxscan980_done:
 .annotate 'line', 470
   # rx literal  "["
-    add $I11, rx1008_pos, 1
-    gt $I11, rx1008_eos, rx1008_fail
-    sub $I11, rx1008_pos, rx1008_off
-    substr $S10, rx1008_tgt, $I11, 1
-    ne $S10, "[", rx1008_fail
-    add rx1008_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx1008_cur."!cursor_pos"(rx1008_pos)
-    $P10 = rx1008_cur."ws"()
-    unless $P10, rx1008_fail
-    rx1008_pos = $P10."pos"()
+    add $I11, rx976_pos, 1
+    gt $I11, rx976_eos, rx976_fail
+    sub $I11, rx976_pos, rx976_off
+    substr $S10, rx976_tgt, $I11, 1
+    ne $S10, "[", rx976_fail
+    add rx976_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx976_cur."!cursor_pos"(rx976_pos)
+    $P10 = rx976_cur."ws"()
+    unless $P10, rx976_fail
+    rx976_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx1008_cur."!cursor_pos"(rx1008_pos)
-    $P10 = rx1008_cur."EXPR"()
-    unless $P10, rx1008_fail
-    rx1008_cur."!mark_push"(0, -1, 0, $P10)
+    rx976_cur."!cursor_pos"(rx976_pos)
+    $P10 = rx976_cur."EXPR"()
+    unless $P10, rx976_fail
+    rx976_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("EXPR")
-    rx1008_pos = $P10."pos"()
+    rx976_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx1008_pos, 1
-    gt $I11, rx1008_eos, rx1008_fail
-    sub $I11, rx1008_pos, rx1008_off
-    substr $S10, rx1008_tgt, $I11, 1
-    ne $S10, "]", rx1008_fail
-    add rx1008_pos, 1
+    add $I11, rx976_pos, 1
+    gt $I11, rx976_eos, rx976_fail
+    sub $I11, rx976_pos, rx976_off
+    substr $S10, rx976_tgt, $I11, 1
+    ne $S10, "]", rx976_fail
+    add rx976_pos, 1
 .annotate 'line', 471
   # rx subrule "O" subtype=capture negate=
-    rx1008_cur."!cursor_pos"(rx1008_pos)
-    $P10 = rx1008_cur."O"("%methodop")
-    unless $P10, rx1008_fail
-    rx1008_cur."!mark_push"(0, -1, 0, $P10)
+    rx976_cur."!cursor_pos"(rx976_pos)
+    $P10 = rx976_cur."O"("%methodop")
+    unless $P10, rx976_fail
+    rx976_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1008_pos = $P10."pos"()
+    rx976_pos = $P10."pos"()
 .annotate 'line', 469
   # rx pass
-    rx1008_cur."!cursor_pass"(rx1008_pos, "postcircumfix:sym<[ ]>")
-    rx1008_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<[ ]>", " at pos=", rx1008_pos)
-    .return (rx1008_cur)
-  rx1008_fail:
+    rx976_cur."!cursor_pass"(rx976_pos, "postcircumfix:sym<[ ]>")
+    rx976_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<[ ]>", " at pos=", rx976_pos)
+    .return (rx976_cur)
+  rx976_restart:
 .annotate 'line', 447
-    (rx1008_rep, rx1008_pos, $I10, $P10) = rx1008_cur."!mark_fail"(0)
-    lt rx1008_pos, -1, rx1008_done
-    eq rx1008_pos, -1, rx1008_fail
+    rx976_cur."!cursor_debug"("NEXT ", "postcircumfix:sym<[ ]>")
+  rx976_fail:
+    (rx976_rep, rx976_pos, $I10, $P10) = rx976_cur."!mark_fail"(0)
+    lt rx976_pos, -1, rx976_done
+    eq rx976_pos, -1, rx976_fail
     jump $I10
-  rx1008_done:
-    rx1008_cur."!cursor_fail"()
-    rx1008_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<[ ]>")
-    .return (rx1008_cur)
+  rx976_done:
+    rx976_cur."!cursor_fail"()
+    rx976_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<[ ]>")
+    .return (rx976_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postcircumfix:sym<[ ]>"  :subid("245_1278500537.15927") :method
+.sub "!PREFIX__postcircumfix:sym<[ ]>"  :subid("245_1279529226.73787") :method
 .annotate 'line', 447
-    $P1010 = self."!PREFIX__!subrule"("ws", "[")
-    new $P1011, "ResizablePMCArray"
-    push $P1011, $P1010
-    .return ($P1011)
+    $P978 = self."!PREFIX__!subrule"("ws", "[")
+    new $P979, "ResizablePMCArray"
+    push $P979, $P978
+    .return ($P979)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postcircumfix:sym<{ }>"  :subid("246_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postcircumfix:sym<{ }>"  :subid("246_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1014_tgt
-    .local int rx1014_pos
-    .local int rx1014_off
-    .local int rx1014_eos
-    .local int rx1014_rep
-    .local pmc rx1014_cur
-    (rx1014_cur, rx1014_pos, rx1014_tgt) = self."!cursor_start"()
-    rx1014_cur."!cursor_debug"("START ", "postcircumfix:sym<{ }>")
-    .lex unicode:"$\x{a2}", rx1014_cur
+    .local string rx982_tgt
+    .local int rx982_pos
+    .local int rx982_off
+    .local int rx982_eos
+    .local int rx982_rep
+    .local pmc rx982_cur
+    (rx982_cur, rx982_pos, rx982_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx982_cur
     .local pmc match
     .lex "$/", match
-    length rx1014_eos, rx1014_tgt
-    gt rx1014_pos, rx1014_eos, rx1014_done
-    set rx1014_off, 0
-    lt rx1014_pos, 2, rx1014_start
-    sub rx1014_off, rx1014_pos, 1
-    substr rx1014_tgt, rx1014_tgt, rx1014_off
-  rx1014_start:
+    length rx982_eos, rx982_tgt
+    gt rx982_pos, rx982_eos, rx982_done
+    set rx982_off, 0
+    lt rx982_pos, 2, rx982_start
+    sub rx982_off, rx982_pos, 1
+    substr rx982_tgt, rx982_tgt, rx982_off
+  rx982_start:
+    eq $I10, 1, rx982_restart
+    rx982_cur."!cursor_debug"("START ", "postcircumfix:sym<{ }>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1018_done
-    goto rxscan1018_scan
-  rxscan1018_loop:
-    ($P10) = rx1014_cur."from"()
+    ne $I10, -1, rxscan986_done
+    goto rxscan986_scan
+  rxscan986_loop:
+    ($P10) = rx982_cur."from"()
     inc $P10
-    set rx1014_pos, $P10
-    ge rx1014_pos, rx1014_eos, rxscan1018_done
-  rxscan1018_scan:
-    set_addr $I10, rxscan1018_loop
-    rx1014_cur."!mark_push"(0, rx1014_pos, $I10)
-  rxscan1018_done:
+    set rx982_pos, $P10
+    ge rx982_pos, rx982_eos, rxscan986_done
+  rxscan986_scan:
+    set_addr $I10, rxscan986_loop
+    rx982_cur."!mark_push"(0, rx982_pos, $I10)
+  rxscan986_done:
 .annotate 'line', 475
   # rx literal  "{"
-    add $I11, rx1014_pos, 1
-    gt $I11, rx1014_eos, rx1014_fail
-    sub $I11, rx1014_pos, rx1014_off
-    substr $S10, rx1014_tgt, $I11, 1
-    ne $S10, "{", rx1014_fail
-    add rx1014_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx1014_cur."!cursor_pos"(rx1014_pos)
-    $P10 = rx1014_cur."ws"()
-    unless $P10, rx1014_fail
-    rx1014_pos = $P10."pos"()
+    add $I11, rx982_pos, 1
+    gt $I11, rx982_eos, rx982_fail
+    sub $I11, rx982_pos, rx982_off
+    substr $S10, rx982_tgt, $I11, 1
+    ne $S10, "{", rx982_fail
+    add rx982_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx982_cur."!cursor_pos"(rx982_pos)
+    $P10 = rx982_cur."ws"()
+    unless $P10, rx982_fail
+    rx982_pos = $P10."pos"()
   # rx subrule "EXPR" subtype=capture negate=
-    rx1014_cur."!cursor_pos"(rx1014_pos)
-    $P10 = rx1014_cur."EXPR"()
-    unless $P10, rx1014_fail
-    rx1014_cur."!mark_push"(0, -1, 0, $P10)
+    rx982_cur."!cursor_pos"(rx982_pos)
+    $P10 = rx982_cur."EXPR"()
+    unless $P10, rx982_fail
+    rx982_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("EXPR")
-    rx1014_pos = $P10."pos"()
+    rx982_pos = $P10."pos"()
   # rx literal  "}"
-    add $I11, rx1014_pos, 1
-    gt $I11, rx1014_eos, rx1014_fail
-    sub $I11, rx1014_pos, rx1014_off
-    substr $S10, rx1014_tgt, $I11, 1
-    ne $S10, "}", rx1014_fail
-    add rx1014_pos, 1
+    add $I11, rx982_pos, 1
+    gt $I11, rx982_eos, rx982_fail
+    sub $I11, rx982_pos, rx982_off
+    substr $S10, rx982_tgt, $I11, 1
+    ne $S10, "}", rx982_fail
+    add rx982_pos, 1
 .annotate 'line', 476
   # rx subrule "O" subtype=capture negate=
-    rx1014_cur."!cursor_pos"(rx1014_pos)
-    $P10 = rx1014_cur."O"("%methodop")
-    unless $P10, rx1014_fail
-    rx1014_cur."!mark_push"(0, -1, 0, $P10)
+    rx982_cur."!cursor_pos"(rx982_pos)
+    $P10 = rx982_cur."O"("%methodop")
+    unless $P10, rx982_fail
+    rx982_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1014_pos = $P10."pos"()
+    rx982_pos = $P10."pos"()
 .annotate 'line', 474
   # rx pass
-    rx1014_cur."!cursor_pass"(rx1014_pos, "postcircumfix:sym<{ }>")
-    rx1014_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<{ }>", " at pos=", rx1014_pos)
-    .return (rx1014_cur)
-  rx1014_fail:
+    rx982_cur."!cursor_pass"(rx982_pos, "postcircumfix:sym<{ }>")
+    rx982_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<{ }>", " at pos=", rx982_pos)
+    .return (rx982_cur)
+  rx982_restart:
 .annotate 'line', 447
-    (rx1014_rep, rx1014_pos, $I10, $P10) = rx1014_cur."!mark_fail"(0)
-    lt rx1014_pos, -1, rx1014_done
-    eq rx1014_pos, -1, rx1014_fail
+    rx982_cur."!cursor_debug"("NEXT ", "postcircumfix:sym<{ }>")
+  rx982_fail:
+    (rx982_rep, rx982_pos, $I10, $P10) = rx982_cur."!mark_fail"(0)
+    lt rx982_pos, -1, rx982_done
+    eq rx982_pos, -1, rx982_fail
     jump $I10
-  rx1014_done:
-    rx1014_cur."!cursor_fail"()
-    rx1014_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<{ }>")
-    .return (rx1014_cur)
+  rx982_done:
+    rx982_cur."!cursor_fail"()
+    rx982_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<{ }>")
+    .return (rx982_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postcircumfix:sym<{ }>"  :subid("247_1278500537.15927") :method
+.sub "!PREFIX__postcircumfix:sym<{ }>"  :subid("247_1279529226.73787") :method
 .annotate 'line', 447
-    $P1016 = self."!PREFIX__!subrule"("ws", "{")
-    new $P1017, "ResizablePMCArray"
-    push $P1017, $P1016
-    .return ($P1017)
+    $P984 = self."!PREFIX__!subrule"("ws", "{")
+    new $P985, "ResizablePMCArray"
+    push $P985, $P984
+    .return ($P985)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postcircumfix:sym<ang>"  :subid("248_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postcircumfix:sym<ang>"  :subid("248_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1020_tgt
-    .local int rx1020_pos
-    .local int rx1020_off
-    .local int rx1020_eos
-    .local int rx1020_rep
-    .local pmc rx1020_cur
-    (rx1020_cur, rx1020_pos, rx1020_tgt) = self."!cursor_start"()
-    rx1020_cur."!cursor_debug"("START ", "postcircumfix:sym<ang>")
-    .lex unicode:"$\x{a2}", rx1020_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1020_eos, rx1020_tgt
-    gt rx1020_pos, rx1020_eos, rx1020_done
-    set rx1020_off, 0
-    lt rx1020_pos, 2, rx1020_start
-    sub rx1020_off, rx1020_pos, 1
-    substr rx1020_tgt, rx1020_tgt, rx1020_off
-  rx1020_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1023_done
-    goto rxscan1023_scan
-  rxscan1023_loop:
-    ($P10) = rx1020_cur."from"()
-    inc $P10
-    set rx1020_pos, $P10
-    ge rx1020_pos, rx1020_eos, rxscan1023_done
-  rxscan1023_scan:
-    set_addr $I10, rxscan1023_loop
-    rx1020_cur."!mark_push"(0, rx1020_pos, $I10)
-  rxscan1023_done:
+    .local string rx988_tgt
+    .local int rx988_pos
+    .local int rx988_off
+    .local int rx988_eos
+    .local int rx988_rep
+    .local pmc rx988_cur
+    (rx988_cur, rx988_pos, rx988_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx988_cur
+    .local pmc match
+    .lex "$/", match
+    length rx988_eos, rx988_tgt
+    gt rx988_pos, rx988_eos, rx988_done
+    set rx988_off, 0
+    lt rx988_pos, 2, rx988_start
+    sub rx988_off, rx988_pos, 1
+    substr rx988_tgt, rx988_tgt, rx988_off
+  rx988_start:
+    eq $I10, 1, rx988_restart
+    rx988_cur."!cursor_debug"("START ", "postcircumfix:sym<ang>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan991_done
+    goto rxscan991_scan
+  rxscan991_loop:
+    ($P10) = rx988_cur."from"()
+    inc $P10
+    set rx988_pos, $P10
+    ge rx988_pos, rx988_eos, rxscan991_done
+  rxscan991_scan:
+    set_addr $I10, rxscan991_loop
+    rx988_cur."!mark_push"(0, rx988_pos, $I10)
+  rxscan991_done:
 .annotate 'line', 480
   # rx enumcharlist negate=0 zerowidth
-    ge rx1020_pos, rx1020_eos, rx1020_fail
-    sub $I10, rx1020_pos, rx1020_off
-    substr $S10, rx1020_tgt, $I10, 1
+    ge rx988_pos, rx988_eos, rx988_fail
+    sub $I10, rx988_pos, rx988_off
+    substr $S10, rx988_tgt, $I10, 1
     index $I11, "<", $S10
-    lt $I11, 0, rx1020_fail
+    lt $I11, 0, rx988_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx1020_cur."!cursor_pos"(rx1020_pos)
-    $P10 = rx1020_cur."quote_EXPR"(":q")
-    unless $P10, rx1020_fail
-    rx1020_cur."!mark_push"(0, -1, 0, $P10)
+    rx988_cur."!cursor_pos"(rx988_pos)
+    $P10 = rx988_cur."quote_EXPR"(":q")
+    unless $P10, rx988_fail
+    rx988_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx1020_pos = $P10."pos"()
+    rx988_pos = $P10."pos"()
 .annotate 'line', 481
   # rx subrule "O" subtype=capture negate=
-    rx1020_cur."!cursor_pos"(rx1020_pos)
-    $P10 = rx1020_cur."O"("%methodop")
-    unless $P10, rx1020_fail
-    rx1020_cur."!mark_push"(0, -1, 0, $P10)
+    rx988_cur."!cursor_pos"(rx988_pos)
+    $P10 = rx988_cur."O"("%methodop")
+    unless $P10, rx988_fail
+    rx988_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1020_pos = $P10."pos"()
+    rx988_pos = $P10."pos"()
 .annotate 'line', 479
   # rx pass
-    rx1020_cur."!cursor_pass"(rx1020_pos, "postcircumfix:sym<ang>")
-    rx1020_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<ang>", " at pos=", rx1020_pos)
-    .return (rx1020_cur)
-  rx1020_fail:
+    rx988_cur."!cursor_pass"(rx988_pos, "postcircumfix:sym<ang>")
+    rx988_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<ang>", " at pos=", rx988_pos)
+    .return (rx988_cur)
+  rx988_restart:
 .annotate 'line', 447
-    (rx1020_rep, rx1020_pos, $I10, $P10) = rx1020_cur."!mark_fail"(0)
-    lt rx1020_pos, -1, rx1020_done
-    eq rx1020_pos, -1, rx1020_fail
+    rx988_cur."!cursor_debug"("NEXT ", "postcircumfix:sym<ang>")
+  rx988_fail:
+    (rx988_rep, rx988_pos, $I10, $P10) = rx988_cur."!mark_fail"(0)
+    lt rx988_pos, -1, rx988_done
+    eq rx988_pos, -1, rx988_fail
     jump $I10
-  rx1020_done:
-    rx1020_cur."!cursor_fail"()
-    rx1020_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<ang>")
-    .return (rx1020_cur)
+  rx988_done:
+    rx988_cur."!cursor_fail"()
+    rx988_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<ang>")
+    .return (rx988_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postcircumfix:sym<ang>"  :subid("249_1278500537.15927") :method
+.sub "!PREFIX__postcircumfix:sym<ang>"  :subid("249_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1022, "ResizablePMCArray"
-    push $P1022, "<"
-    .return ($P1022)
+    new $P990, "ResizablePMCArray"
+    push $P990, "<"
+    .return ($P990)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postcircumfix:sym<( )>"  :subid("250_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postcircumfix:sym<( )>"  :subid("250_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1025_tgt
-    .local int rx1025_pos
-    .local int rx1025_off
-    .local int rx1025_eos
-    .local int rx1025_rep
-    .local pmc rx1025_cur
-    (rx1025_cur, rx1025_pos, rx1025_tgt) = self."!cursor_start"()
-    rx1025_cur."!cursor_debug"("START ", "postcircumfix:sym<( )>")
-    .lex unicode:"$\x{a2}", rx1025_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1025_eos, rx1025_tgt
-    gt rx1025_pos, rx1025_eos, rx1025_done
-    set rx1025_off, 0
-    lt rx1025_pos, 2, rx1025_start
-    sub rx1025_off, rx1025_pos, 1
-    substr rx1025_tgt, rx1025_tgt, rx1025_off
-  rx1025_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1029_done
-    goto rxscan1029_scan
-  rxscan1029_loop:
-    ($P10) = rx1025_cur."from"()
-    inc $P10
-    set rx1025_pos, $P10
-    ge rx1025_pos, rx1025_eos, rxscan1029_done
-  rxscan1029_scan:
-    set_addr $I10, rxscan1029_loop
-    rx1025_cur."!mark_push"(0, rx1025_pos, $I10)
-  rxscan1029_done:
+    .local string rx993_tgt
+    .local int rx993_pos
+    .local int rx993_off
+    .local int rx993_eos
+    .local int rx993_rep
+    .local pmc rx993_cur
+    (rx993_cur, rx993_pos, rx993_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx993_cur
+    .local pmc match
+    .lex "$/", match
+    length rx993_eos, rx993_tgt
+    gt rx993_pos, rx993_eos, rx993_done
+    set rx993_off, 0
+    lt rx993_pos, 2, rx993_start
+    sub rx993_off, rx993_pos, 1
+    substr rx993_tgt, rx993_tgt, rx993_off
+  rx993_start:
+    eq $I10, 1, rx993_restart
+    rx993_cur."!cursor_debug"("START ", "postcircumfix:sym<( )>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan997_done
+    goto rxscan997_scan
+  rxscan997_loop:
+    ($P10) = rx993_cur."from"()
+    inc $P10
+    set rx993_pos, $P10
+    ge rx993_pos, rx993_eos, rxscan997_done
+  rxscan997_scan:
+    set_addr $I10, rxscan997_loop
+    rx993_cur."!mark_push"(0, rx993_pos, $I10)
+  rxscan997_done:
 .annotate 'line', 485
   # rx literal  "("
-    add $I11, rx1025_pos, 1
-    gt $I11, rx1025_eos, rx1025_fail
-    sub $I11, rx1025_pos, rx1025_off
-    substr $S10, rx1025_tgt, $I11, 1
-    ne $S10, "(", rx1025_fail
-    add rx1025_pos, 1
-  # rx subrule "ws" subtype=method negate=
-    rx1025_cur."!cursor_pos"(rx1025_pos)
-    $P10 = rx1025_cur."ws"()
-    unless $P10, rx1025_fail
-    rx1025_pos = $P10."pos"()
+    add $I11, rx993_pos, 1
+    gt $I11, rx993_eos, rx993_fail
+    sub $I11, rx993_pos, rx993_off
+    substr $S10, rx993_tgt, $I11, 1
+    ne $S10, "(", rx993_fail
+    add rx993_pos, 1
+  # rx subrule "ws" subtype=method negate=
+    rx993_cur."!cursor_pos"(rx993_pos)
+    $P10 = rx993_cur."ws"()
+    unless $P10, rx993_fail
+    rx993_pos = $P10."pos"()
   # rx subrule "arglist" subtype=capture negate=
-    rx1025_cur."!cursor_pos"(rx1025_pos)
-    $P10 = rx1025_cur."arglist"()
-    unless $P10, rx1025_fail
-    rx1025_cur."!mark_push"(0, -1, 0, $P10)
+    rx993_cur."!cursor_pos"(rx993_pos)
+    $P10 = rx993_cur."arglist"()
+    unless $P10, rx993_fail
+    rx993_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("arglist")
-    rx1025_pos = $P10."pos"()
+    rx993_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx1025_pos, 1
-    gt $I11, rx1025_eos, rx1025_fail
-    sub $I11, rx1025_pos, rx1025_off
-    substr $S10, rx1025_tgt, $I11, 1
-    ne $S10, ")", rx1025_fail
-    add rx1025_pos, 1
+    add $I11, rx993_pos, 1
+    gt $I11, rx993_eos, rx993_fail
+    sub $I11, rx993_pos, rx993_off
+    substr $S10, rx993_tgt, $I11, 1
+    ne $S10, ")", rx993_fail
+    add rx993_pos, 1
 .annotate 'line', 486
   # rx subrule "O" subtype=capture negate=
-    rx1025_cur."!cursor_pos"(rx1025_pos)
-    $P10 = rx1025_cur."O"("%methodop")
-    unless $P10, rx1025_fail
-    rx1025_cur."!mark_push"(0, -1, 0, $P10)
+    rx993_cur."!cursor_pos"(rx993_pos)
+    $P10 = rx993_cur."O"("%methodop")
+    unless $P10, rx993_fail
+    rx993_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1025_pos = $P10."pos"()
+    rx993_pos = $P10."pos"()
 .annotate 'line', 484
   # rx pass
-    rx1025_cur."!cursor_pass"(rx1025_pos, "postcircumfix:sym<( )>")
-    rx1025_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<( )>", " at pos=", rx1025_pos)
-    .return (rx1025_cur)
-  rx1025_fail:
+    rx993_cur."!cursor_pass"(rx993_pos, "postcircumfix:sym<( )>")
+    rx993_cur."!cursor_debug"("PASS  ", "postcircumfix:sym<( )>", " at pos=", rx993_pos)
+    .return (rx993_cur)
+  rx993_restart:
 .annotate 'line', 447
-    (rx1025_rep, rx1025_pos, $I10, $P10) = rx1025_cur."!mark_fail"(0)
-    lt rx1025_pos, -1, rx1025_done
-    eq rx1025_pos, -1, rx1025_fail
+    rx993_cur."!cursor_debug"("NEXT ", "postcircumfix:sym<( )>")
+  rx993_fail:
+    (rx993_rep, rx993_pos, $I10, $P10) = rx993_cur."!mark_fail"(0)
+    lt rx993_pos, -1, rx993_done
+    eq rx993_pos, -1, rx993_fail
     jump $I10
-  rx1025_done:
-    rx1025_cur."!cursor_fail"()
-    rx1025_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<( )>")
-    .return (rx1025_cur)
+  rx993_done:
+    rx993_cur."!cursor_fail"()
+    rx993_cur."!cursor_debug"("FAIL  ", "postcircumfix:sym<( )>")
+    .return (rx993_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postcircumfix:sym<( )>"  :subid("251_1278500537.15927") :method
+.sub "!PREFIX__postcircumfix:sym<( )>"  :subid("251_1279529226.73787") :method
 .annotate 'line', 447
-    $P1027 = self."!PREFIX__!subrule"("ws", "(")
-    new $P1028, "ResizablePMCArray"
-    push $P1028, $P1027
-    .return ($P1028)
+    $P995 = self."!PREFIX__!subrule"("ws", "(")
+    new $P996, "ResizablePMCArray"
+    push $P996, $P995
+    .return ($P996)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postfix:sym<.>"  :subid("252_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postfix:sym<.>"  :subid("252_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1031_tgt
-    .local int rx1031_pos
-    .local int rx1031_off
-    .local int rx1031_eos
-    .local int rx1031_rep
-    .local pmc rx1031_cur
-    (rx1031_cur, rx1031_pos, rx1031_tgt) = self."!cursor_start"()
-    rx1031_cur."!cursor_debug"("START ", "postfix:sym<.>")
-    .lex unicode:"$\x{a2}", rx1031_cur
+    .local string rx999_tgt
+    .local int rx999_pos
+    .local int rx999_off
+    .local int rx999_eos
+    .local int rx999_rep
+    .local pmc rx999_cur
+    (rx999_cur, rx999_pos, rx999_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx999_cur
     .local pmc match
     .lex "$/", match
-    length rx1031_eos, rx1031_tgt
-    gt rx1031_pos, rx1031_eos, rx1031_done
-    set rx1031_off, 0
-    lt rx1031_pos, 2, rx1031_start
-    sub rx1031_off, rx1031_pos, 1
-    substr rx1031_tgt, rx1031_tgt, rx1031_off
-  rx1031_start:
+    length rx999_eos, rx999_tgt
+    gt rx999_pos, rx999_eos, rx999_done
+    set rx999_off, 0
+    lt rx999_pos, 2, rx999_start
+    sub rx999_off, rx999_pos, 1
+    substr rx999_tgt, rx999_tgt, rx999_off
+  rx999_start:
+    eq $I10, 1, rx999_restart
+    rx999_cur."!cursor_debug"("START ", "postfix:sym<.>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1035_done
-    goto rxscan1035_scan
-  rxscan1035_loop:
-    ($P10) = rx1031_cur."from"()
+    ne $I10, -1, rxscan1003_done
+    goto rxscan1003_scan
+  rxscan1003_loop:
+    ($P10) = rx999_cur."from"()
     inc $P10
-    set rx1031_pos, $P10
-    ge rx1031_pos, rx1031_eos, rxscan1035_done
-  rxscan1035_scan:
-    set_addr $I10, rxscan1035_loop
-    rx1031_cur."!mark_push"(0, rx1031_pos, $I10)
-  rxscan1035_done:
+    set rx999_pos, $P10
+    ge rx999_pos, rx999_eos, rxscan1003_done
+  rxscan1003_scan:
+    set_addr $I10, rxscan1003_loop
+    rx999_cur."!mark_push"(0, rx999_pos, $I10)
+  rxscan1003_done:
 .annotate 'line', 489
   # rx subrule "dotty" subtype=capture negate=
-    rx1031_cur."!cursor_pos"(rx1031_pos)
-    $P10 = rx1031_cur."dotty"()
-    unless $P10, rx1031_fail
-    rx1031_cur."!mark_push"(0, -1, 0, $P10)
+    rx999_cur."!cursor_pos"(rx999_pos)
+    $P10 = rx999_cur."dotty"()
+    unless $P10, rx999_fail
+    rx999_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("dotty")
-    rx1031_pos = $P10."pos"()
+    rx999_pos = $P10."pos"()
   # rx subrule "O" subtype=capture negate=
-    rx1031_cur."!cursor_pos"(rx1031_pos)
-    $P10 = rx1031_cur."O"("%methodop")
-    unless $P10, rx1031_fail
-    rx1031_cur."!mark_push"(0, -1, 0, $P10)
+    rx999_cur."!cursor_pos"(rx999_pos)
+    $P10 = rx999_cur."O"("%methodop")
+    unless $P10, rx999_fail
+    rx999_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1031_pos = $P10."pos"()
+    rx999_pos = $P10."pos"()
   # rx pass
-    rx1031_cur."!cursor_pass"(rx1031_pos, "postfix:sym<.>")
-    rx1031_cur."!cursor_debug"("PASS  ", "postfix:sym<.>", " at pos=", rx1031_pos)
-    .return (rx1031_cur)
-  rx1031_fail:
+    rx999_cur."!cursor_pass"(rx999_pos, "postfix:sym<.>")
+    rx999_cur."!cursor_debug"("PASS  ", "postfix:sym<.>", " at pos=", rx999_pos)
+    .return (rx999_cur)
+  rx999_restart:
 .annotate 'line', 447
-    (rx1031_rep, rx1031_pos, $I10, $P10) = rx1031_cur."!mark_fail"(0)
-    lt rx1031_pos, -1, rx1031_done
-    eq rx1031_pos, -1, rx1031_fail
+    rx999_cur."!cursor_debug"("NEXT ", "postfix:sym<.>")
+  rx999_fail:
+    (rx999_rep, rx999_pos, $I10, $P10) = rx999_cur."!mark_fail"(0)
+    lt rx999_pos, -1, rx999_done
+    eq rx999_pos, -1, rx999_fail
     jump $I10
-  rx1031_done:
-    rx1031_cur."!cursor_fail"()
-    rx1031_cur."!cursor_debug"("FAIL  ", "postfix:sym<.>")
-    .return (rx1031_cur)
+  rx999_done:
+    rx999_cur."!cursor_fail"()
+    rx999_cur."!cursor_debug"("FAIL  ", "postfix:sym<.>")
+    .return (rx999_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postfix:sym<.>"  :subid("253_1278500537.15927") :method
+.sub "!PREFIX__postfix:sym<.>"  :subid("253_1279529226.73787") :method
 .annotate 'line', 447
-    $P1033 = self."!PREFIX__!subrule"("dotty", "")
-    new $P1034, "ResizablePMCArray"
-    push $P1034, $P1033
-    .return ($P1034)
+    $P1001 = self."!PREFIX__!subrule"("dotty", "")
+    new $P1002, "ResizablePMCArray"
+    push $P1002, $P1001
+    .return ($P1002)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<++>"  :subid("254_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<++>"  :subid("254_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1037_tgt
-    .local int rx1037_pos
-    .local int rx1037_off
-    .local int rx1037_eos
-    .local int rx1037_rep
-    .local pmc rx1037_cur
-    (rx1037_cur, rx1037_pos, rx1037_tgt) = self."!cursor_start"()
-    rx1037_cur."!cursor_debug"("START ", "prefix:sym<++>")
-    .lex unicode:"$\x{a2}", rx1037_cur
+    .local string rx1005_tgt
+    .local int rx1005_pos
+    .local int rx1005_off
+    .local int rx1005_eos
+    .local int rx1005_rep
+    .local pmc rx1005_cur
+    (rx1005_cur, rx1005_pos, rx1005_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1005_cur
     .local pmc match
     .lex "$/", match
-    length rx1037_eos, rx1037_tgt
-    gt rx1037_pos, rx1037_eos, rx1037_done
-    set rx1037_off, 0
-    lt rx1037_pos, 2, rx1037_start
-    sub rx1037_off, rx1037_pos, 1
-    substr rx1037_tgt, rx1037_tgt, rx1037_off
-  rx1037_start:
+    length rx1005_eos, rx1005_tgt
+    gt rx1005_pos, rx1005_eos, rx1005_done
+    set rx1005_off, 0
+    lt rx1005_pos, 2, rx1005_start
+    sub rx1005_off, rx1005_pos, 1
+    substr rx1005_tgt, rx1005_tgt, rx1005_off
+  rx1005_start:
+    eq $I10, 1, rx1005_restart
+    rx1005_cur."!cursor_debug"("START ", "prefix:sym<++>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1041_done
-    goto rxscan1041_scan
-  rxscan1041_loop:
-    ($P10) = rx1037_cur."from"()
+    ne $I10, -1, rxscan1009_done
+    goto rxscan1009_scan
+  rxscan1009_loop:
+    ($P10) = rx1005_cur."from"()
     inc $P10
-    set rx1037_pos, $P10
-    ge rx1037_pos, rx1037_eos, rxscan1041_done
-  rxscan1041_scan:
-    set_addr $I10, rxscan1041_loop
-    rx1037_cur."!mark_push"(0, rx1037_pos, $I10)
-  rxscan1041_done:
+    set rx1005_pos, $P10
+    ge rx1005_pos, rx1005_eos, rxscan1009_done
+  rxscan1009_scan:
+    set_addr $I10, rxscan1009_loop
+    rx1005_cur."!mark_push"(0, rx1005_pos, $I10)
+  rxscan1009_done:
 .annotate 'line', 491
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1042_fail
-    rx1037_cur."!mark_push"(0, rx1037_pos, $I10)
+    set_addr $I10, rxcap_1010_fail
+    rx1005_cur."!mark_push"(0, rx1005_pos, $I10)
   # rx literal  "++"
-    add $I11, rx1037_pos, 2
-    gt $I11, rx1037_eos, rx1037_fail
-    sub $I11, rx1037_pos, rx1037_off
-    substr $S10, rx1037_tgt, $I11, 2
-    ne $S10, "++", rx1037_fail
-    add rx1037_pos, 2
-    set_addr $I10, rxcap_1042_fail
-    ($I12, $I11) = rx1037_cur."!mark_peek"($I10)
-    rx1037_cur."!cursor_pos"($I11)
-    ($P10) = rx1037_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1037_pos, "")
-    rx1037_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1005_pos, 2
+    gt $I11, rx1005_eos, rx1005_fail
+    sub $I11, rx1005_pos, rx1005_off
+    substr $S10, rx1005_tgt, $I11, 2
+    ne $S10, "++", rx1005_fail
+    add rx1005_pos, 2
+    set_addr $I10, rxcap_1010_fail
+    ($I12, $I11) = rx1005_cur."!mark_peek"($I10)
+    rx1005_cur."!cursor_pos"($I11)
+    ($P10) = rx1005_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1005_pos, "")
+    rx1005_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1042_done
-  rxcap_1042_fail:
-    goto rx1037_fail
-  rxcap_1042_done:
+    goto rxcap_1010_done
+  rxcap_1010_fail:
+    goto rx1005_fail
+  rxcap_1010_done:
   # rx subrule "O" subtype=capture negate=
-    rx1037_cur."!cursor_pos"(rx1037_pos)
-    $P10 = rx1037_cur."O"("%autoincrement, :pirop<inc>")
-    unless $P10, rx1037_fail
-    rx1037_cur."!mark_push"(0, -1, 0, $P10)
+    rx1005_cur."!cursor_pos"(rx1005_pos)
+    $P10 = rx1005_cur."O"("%autoincrement, :pirop<inc>")
+    unless $P10, rx1005_fail
+    rx1005_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1037_pos = $P10."pos"()
+    rx1005_pos = $P10."pos"()
   # rx pass
-    rx1037_cur."!cursor_pass"(rx1037_pos, "prefix:sym<++>")
-    rx1037_cur."!cursor_debug"("PASS  ", "prefix:sym<++>", " at pos=", rx1037_pos)
-    .return (rx1037_cur)
-  rx1037_fail:
+    rx1005_cur."!cursor_pass"(rx1005_pos, "prefix:sym<++>")
+    rx1005_cur."!cursor_debug"("PASS  ", "prefix:sym<++>", " at pos=", rx1005_pos)
+    .return (rx1005_cur)
+  rx1005_restart:
 .annotate 'line', 447
-    (rx1037_rep, rx1037_pos, $I10, $P10) = rx1037_cur."!mark_fail"(0)
-    lt rx1037_pos, -1, rx1037_done
-    eq rx1037_pos, -1, rx1037_fail
+    rx1005_cur."!cursor_debug"("NEXT ", "prefix:sym<++>")
+  rx1005_fail:
+    (rx1005_rep, rx1005_pos, $I10, $P10) = rx1005_cur."!mark_fail"(0)
+    lt rx1005_pos, -1, rx1005_done
+    eq rx1005_pos, -1, rx1005_fail
     jump $I10
-  rx1037_done:
-    rx1037_cur."!cursor_fail"()
-    rx1037_cur."!cursor_debug"("FAIL  ", "prefix:sym<++>")
-    .return (rx1037_cur)
+  rx1005_done:
+    rx1005_cur."!cursor_fail"()
+    rx1005_cur."!cursor_debug"("FAIL  ", "prefix:sym<++>")
+    .return (rx1005_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<++>"  :subid("255_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<++>"  :subid("255_1279529226.73787") :method
 .annotate 'line', 447
-    $P1039 = self."!PREFIX__!subrule"("O", "++")
-    new $P1040, "ResizablePMCArray"
-    push $P1040, $P1039
-    .return ($P1040)
+    $P1007 = self."!PREFIX__!subrule"("O", "++")
+    new $P1008, "ResizablePMCArray"
+    push $P1008, $P1007
+    .return ($P1008)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<-->"  :subid("256_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<-->"  :subid("256_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1044_tgt
-    .local int rx1044_pos
-    .local int rx1044_off
-    .local int rx1044_eos
-    .local int rx1044_rep
-    .local pmc rx1044_cur
-    (rx1044_cur, rx1044_pos, rx1044_tgt) = self."!cursor_start"()
-    rx1044_cur."!cursor_debug"("START ", "prefix:sym<-->")
-    .lex unicode:"$\x{a2}", rx1044_cur
+    .local string rx1012_tgt
+    .local int rx1012_pos
+    .local int rx1012_off
+    .local int rx1012_eos
+    .local int rx1012_rep
+    .local pmc rx1012_cur
+    (rx1012_cur, rx1012_pos, rx1012_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1012_cur
     .local pmc match
     .lex "$/", match
-    length rx1044_eos, rx1044_tgt
-    gt rx1044_pos, rx1044_eos, rx1044_done
-    set rx1044_off, 0
-    lt rx1044_pos, 2, rx1044_start
-    sub rx1044_off, rx1044_pos, 1
-    substr rx1044_tgt, rx1044_tgt, rx1044_off
-  rx1044_start:
+    length rx1012_eos, rx1012_tgt
+    gt rx1012_pos, rx1012_eos, rx1012_done
+    set rx1012_off, 0
+    lt rx1012_pos, 2, rx1012_start
+    sub rx1012_off, rx1012_pos, 1
+    substr rx1012_tgt, rx1012_tgt, rx1012_off
+  rx1012_start:
+    eq $I10, 1, rx1012_restart
+    rx1012_cur."!cursor_debug"("START ", "prefix:sym<-->")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1048_done
-    goto rxscan1048_scan
-  rxscan1048_loop:
-    ($P10) = rx1044_cur."from"()
+    ne $I10, -1, rxscan1016_done
+    goto rxscan1016_scan
+  rxscan1016_loop:
+    ($P10) = rx1012_cur."from"()
     inc $P10
-    set rx1044_pos, $P10
-    ge rx1044_pos, rx1044_eos, rxscan1048_done
-  rxscan1048_scan:
-    set_addr $I10, rxscan1048_loop
-    rx1044_cur."!mark_push"(0, rx1044_pos, $I10)
-  rxscan1048_done:
+    set rx1012_pos, $P10
+    ge rx1012_pos, rx1012_eos, rxscan1016_done
+  rxscan1016_scan:
+    set_addr $I10, rxscan1016_loop
+    rx1012_cur."!mark_push"(0, rx1012_pos, $I10)
+  rxscan1016_done:
 .annotate 'line', 492
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1049_fail
-    rx1044_cur."!mark_push"(0, rx1044_pos, $I10)
+    set_addr $I10, rxcap_1017_fail
+    rx1012_cur."!mark_push"(0, rx1012_pos, $I10)
   # rx literal  "--"
-    add $I11, rx1044_pos, 2
-    gt $I11, rx1044_eos, rx1044_fail
-    sub $I11, rx1044_pos, rx1044_off
-    substr $S10, rx1044_tgt, $I11, 2
-    ne $S10, "--", rx1044_fail
-    add rx1044_pos, 2
-    set_addr $I10, rxcap_1049_fail
-    ($I12, $I11) = rx1044_cur."!mark_peek"($I10)
-    rx1044_cur."!cursor_pos"($I11)
-    ($P10) = rx1044_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1044_pos, "")
-    rx1044_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1012_pos, 2
+    gt $I11, rx1012_eos, rx1012_fail
+    sub $I11, rx1012_pos, rx1012_off
+    substr $S10, rx1012_tgt, $I11, 2
+    ne $S10, "--", rx1012_fail
+    add rx1012_pos, 2
+    set_addr $I10, rxcap_1017_fail
+    ($I12, $I11) = rx1012_cur."!mark_peek"($I10)
+    rx1012_cur."!cursor_pos"($I11)
+    ($P10) = rx1012_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1012_pos, "")
+    rx1012_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1049_done
-  rxcap_1049_fail:
-    goto rx1044_fail
-  rxcap_1049_done:
+    goto rxcap_1017_done
+  rxcap_1017_fail:
+    goto rx1012_fail
+  rxcap_1017_done:
   # rx subrule "O" subtype=capture negate=
-    rx1044_cur."!cursor_pos"(rx1044_pos)
-    $P10 = rx1044_cur."O"("%autoincrement, :pirop<dec>")
-    unless $P10, rx1044_fail
-    rx1044_cur."!mark_push"(0, -1, 0, $P10)
+    rx1012_cur."!cursor_pos"(rx1012_pos)
+    $P10 = rx1012_cur."O"("%autoincrement, :pirop<dec>")
+    unless $P10, rx1012_fail
+    rx1012_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1044_pos = $P10."pos"()
+    rx1012_pos = $P10."pos"()
   # rx pass
-    rx1044_cur."!cursor_pass"(rx1044_pos, "prefix:sym<-->")
-    rx1044_cur."!cursor_debug"("PASS  ", "prefix:sym<-->", " at pos=", rx1044_pos)
-    .return (rx1044_cur)
-  rx1044_fail:
+    rx1012_cur."!cursor_pass"(rx1012_pos, "prefix:sym<-->")
+    rx1012_cur."!cursor_debug"("PASS  ", "prefix:sym<-->", " at pos=", rx1012_pos)
+    .return (rx1012_cur)
+  rx1012_restart:
 .annotate 'line', 447
-    (rx1044_rep, rx1044_pos, $I10, $P10) = rx1044_cur."!mark_fail"(0)
-    lt rx1044_pos, -1, rx1044_done
-    eq rx1044_pos, -1, rx1044_fail
+    rx1012_cur."!cursor_debug"("NEXT ", "prefix:sym<-->")
+  rx1012_fail:
+    (rx1012_rep, rx1012_pos, $I10, $P10) = rx1012_cur."!mark_fail"(0)
+    lt rx1012_pos, -1, rx1012_done
+    eq rx1012_pos, -1, rx1012_fail
     jump $I10
-  rx1044_done:
-    rx1044_cur."!cursor_fail"()
-    rx1044_cur."!cursor_debug"("FAIL  ", "prefix:sym<-->")
-    .return (rx1044_cur)
+  rx1012_done:
+    rx1012_cur."!cursor_fail"()
+    rx1012_cur."!cursor_debug"("FAIL  ", "prefix:sym<-->")
+    .return (rx1012_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<-->"  :subid("257_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<-->"  :subid("257_1279529226.73787") :method
 .annotate 'line', 447
-    $P1046 = self."!PREFIX__!subrule"("O", "--")
-    new $P1047, "ResizablePMCArray"
-    push $P1047, $P1046
-    .return ($P1047)
+    $P1014 = self."!PREFIX__!subrule"("O", "--")
+    new $P1015, "ResizablePMCArray"
+    push $P1015, $P1014
+    .return ($P1015)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postfix:sym<++>"  :subid("258_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postfix:sym<++>"  :subid("258_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1051_tgt
-    .local int rx1051_pos
-    .local int rx1051_off
-    .local int rx1051_eos
-    .local int rx1051_rep
-    .local pmc rx1051_cur
-    (rx1051_cur, rx1051_pos, rx1051_tgt) = self."!cursor_start"()
-    rx1051_cur."!cursor_debug"("START ", "postfix:sym<++>")
-    .lex unicode:"$\x{a2}", rx1051_cur
+    .local string rx1019_tgt
+    .local int rx1019_pos
+    .local int rx1019_off
+    .local int rx1019_eos
+    .local int rx1019_rep
+    .local pmc rx1019_cur
+    (rx1019_cur, rx1019_pos, rx1019_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1019_cur
     .local pmc match
     .lex "$/", match
-    length rx1051_eos, rx1051_tgt
-    gt rx1051_pos, rx1051_eos, rx1051_done
-    set rx1051_off, 0
-    lt rx1051_pos, 2, rx1051_start
-    sub rx1051_off, rx1051_pos, 1
-    substr rx1051_tgt, rx1051_tgt, rx1051_off
-  rx1051_start:
+    length rx1019_eos, rx1019_tgt
+    gt rx1019_pos, rx1019_eos, rx1019_done
+    set rx1019_off, 0
+    lt rx1019_pos, 2, rx1019_start
+    sub rx1019_off, rx1019_pos, 1
+    substr rx1019_tgt, rx1019_tgt, rx1019_off
+  rx1019_start:
+    eq $I10, 1, rx1019_restart
+    rx1019_cur."!cursor_debug"("START ", "postfix:sym<++>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1055_done
-    goto rxscan1055_scan
-  rxscan1055_loop:
-    ($P10) = rx1051_cur."from"()
+    ne $I10, -1, rxscan1023_done
+    goto rxscan1023_scan
+  rxscan1023_loop:
+    ($P10) = rx1019_cur."from"()
     inc $P10
-    set rx1051_pos, $P10
-    ge rx1051_pos, rx1051_eos, rxscan1055_done
-  rxscan1055_scan:
-    set_addr $I10, rxscan1055_loop
-    rx1051_cur."!mark_push"(0, rx1051_pos, $I10)
-  rxscan1055_done:
+    set rx1019_pos, $P10
+    ge rx1019_pos, rx1019_eos, rxscan1023_done
+  rxscan1023_scan:
+    set_addr $I10, rxscan1023_loop
+    rx1019_cur."!mark_push"(0, rx1019_pos, $I10)
+  rxscan1023_done:
 .annotate 'line', 495
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1056_fail
-    rx1051_cur."!mark_push"(0, rx1051_pos, $I10)
+    set_addr $I10, rxcap_1024_fail
+    rx1019_cur."!mark_push"(0, rx1019_pos, $I10)
   # rx literal  "++"
-    add $I11, rx1051_pos, 2
-    gt $I11, rx1051_eos, rx1051_fail
-    sub $I11, rx1051_pos, rx1051_off
-    substr $S10, rx1051_tgt, $I11, 2
-    ne $S10, "++", rx1051_fail
-    add rx1051_pos, 2
-    set_addr $I10, rxcap_1056_fail
-    ($I12, $I11) = rx1051_cur."!mark_peek"($I10)
-    rx1051_cur."!cursor_pos"($I11)
-    ($P10) = rx1051_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1051_pos, "")
-    rx1051_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1019_pos, 2
+    gt $I11, rx1019_eos, rx1019_fail
+    sub $I11, rx1019_pos, rx1019_off
+    substr $S10, rx1019_tgt, $I11, 2
+    ne $S10, "++", rx1019_fail
+    add rx1019_pos, 2
+    set_addr $I10, rxcap_1024_fail
+    ($I12, $I11) = rx1019_cur."!mark_peek"($I10)
+    rx1019_cur."!cursor_pos"($I11)
+    ($P10) = rx1019_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1019_pos, "")
+    rx1019_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1056_done
-  rxcap_1056_fail:
-    goto rx1051_fail
-  rxcap_1056_done:
+    goto rxcap_1024_done
+  rxcap_1024_fail:
+    goto rx1019_fail
+  rxcap_1024_done:
   # rx subrule "O" subtype=capture negate=
-    rx1051_cur."!cursor_pos"(rx1051_pos)
-    $P10 = rx1051_cur."O"("%autoincrement")
-    unless $P10, rx1051_fail
-    rx1051_cur."!mark_push"(0, -1, 0, $P10)
+    rx1019_cur."!cursor_pos"(rx1019_pos)
+    $P10 = rx1019_cur."O"("%autoincrement")
+    unless $P10, rx1019_fail
+    rx1019_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1051_pos = $P10."pos"()
+    rx1019_pos = $P10."pos"()
   # rx pass
-    rx1051_cur."!cursor_pass"(rx1051_pos, "postfix:sym<++>")
-    rx1051_cur."!cursor_debug"("PASS  ", "postfix:sym<++>", " at pos=", rx1051_pos)
-    .return (rx1051_cur)
-  rx1051_fail:
+    rx1019_cur."!cursor_pass"(rx1019_pos, "postfix:sym<++>")
+    rx1019_cur."!cursor_debug"("PASS  ", "postfix:sym<++>", " at pos=", rx1019_pos)
+    .return (rx1019_cur)
+  rx1019_restart:
 .annotate 'line', 447
-    (rx1051_rep, rx1051_pos, $I10, $P10) = rx1051_cur."!mark_fail"(0)
-    lt rx1051_pos, -1, rx1051_done
-    eq rx1051_pos, -1, rx1051_fail
+    rx1019_cur."!cursor_debug"("NEXT ", "postfix:sym<++>")
+  rx1019_fail:
+    (rx1019_rep, rx1019_pos, $I10, $P10) = rx1019_cur."!mark_fail"(0)
+    lt rx1019_pos, -1, rx1019_done
+    eq rx1019_pos, -1, rx1019_fail
     jump $I10
-  rx1051_done:
-    rx1051_cur."!cursor_fail"()
-    rx1051_cur."!cursor_debug"("FAIL  ", "postfix:sym<++>")
-    .return (rx1051_cur)
+  rx1019_done:
+    rx1019_cur."!cursor_fail"()
+    rx1019_cur."!cursor_debug"("FAIL  ", "postfix:sym<++>")
+    .return (rx1019_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postfix:sym<++>"  :subid("259_1278500537.15927") :method
+.sub "!PREFIX__postfix:sym<++>"  :subid("259_1279529226.73787") :method
 .annotate 'line', 447
-    $P1053 = self."!PREFIX__!subrule"("O", "++")
-    new $P1054, "ResizablePMCArray"
-    push $P1054, $P1053
-    .return ($P1054)
+    $P1021 = self."!PREFIX__!subrule"("O", "++")
+    new $P1022, "ResizablePMCArray"
+    push $P1022, $P1021
+    .return ($P1022)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "postfix:sym<-->"  :subid("260_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "postfix:sym<-->"  :subid("260_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1058_tgt
-    .local int rx1058_pos
-    .local int rx1058_off
-    .local int rx1058_eos
-    .local int rx1058_rep
-    .local pmc rx1058_cur
-    (rx1058_cur, rx1058_pos, rx1058_tgt) = self."!cursor_start"()
-    rx1058_cur."!cursor_debug"("START ", "postfix:sym<-->")
-    .lex unicode:"$\x{a2}", rx1058_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1058_eos, rx1058_tgt
-    gt rx1058_pos, rx1058_eos, rx1058_done
-    set rx1058_off, 0
-    lt rx1058_pos, 2, rx1058_start
-    sub rx1058_off, rx1058_pos, 1
-    substr rx1058_tgt, rx1058_tgt, rx1058_off
-  rx1058_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1062_done
-    goto rxscan1062_scan
-  rxscan1062_loop:
-    ($P10) = rx1058_cur."from"()
-    inc $P10
-    set rx1058_pos, $P10
-    ge rx1058_pos, rx1058_eos, rxscan1062_done
-  rxscan1062_scan:
-    set_addr $I10, rxscan1062_loop
-    rx1058_cur."!mark_push"(0, rx1058_pos, $I10)
-  rxscan1062_done:
+    .local string rx1026_tgt
+    .local int rx1026_pos
+    .local int rx1026_off
+    .local int rx1026_eos
+    .local int rx1026_rep
+    .local pmc rx1026_cur
+    (rx1026_cur, rx1026_pos, rx1026_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1026_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1026_eos, rx1026_tgt
+    gt rx1026_pos, rx1026_eos, rx1026_done
+    set rx1026_off, 0
+    lt rx1026_pos, 2, rx1026_start
+    sub rx1026_off, rx1026_pos, 1
+    substr rx1026_tgt, rx1026_tgt, rx1026_off
+  rx1026_start:
+    eq $I10, 1, rx1026_restart
+    rx1026_cur."!cursor_debug"("START ", "postfix:sym<-->")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1030_done
+    goto rxscan1030_scan
+  rxscan1030_loop:
+    ($P10) = rx1026_cur."from"()
+    inc $P10
+    set rx1026_pos, $P10
+    ge rx1026_pos, rx1026_eos, rxscan1030_done
+  rxscan1030_scan:
+    set_addr $I10, rxscan1030_loop
+    rx1026_cur."!mark_push"(0, rx1026_pos, $I10)
+  rxscan1030_done:
 .annotate 'line', 496
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1063_fail
-    rx1058_cur."!mark_push"(0, rx1058_pos, $I10)
+    set_addr $I10, rxcap_1031_fail
+    rx1026_cur."!mark_push"(0, rx1026_pos, $I10)
   # rx literal  "--"
-    add $I11, rx1058_pos, 2
-    gt $I11, rx1058_eos, rx1058_fail
-    sub $I11, rx1058_pos, rx1058_off
-    substr $S10, rx1058_tgt, $I11, 2
-    ne $S10, "--", rx1058_fail
-    add rx1058_pos, 2
-    set_addr $I10, rxcap_1063_fail
-    ($I12, $I11) = rx1058_cur."!mark_peek"($I10)
-    rx1058_cur."!cursor_pos"($I11)
-    ($P10) = rx1058_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1058_pos, "")
-    rx1058_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1026_pos, 2
+    gt $I11, rx1026_eos, rx1026_fail
+    sub $I11, rx1026_pos, rx1026_off
+    substr $S10, rx1026_tgt, $I11, 2
+    ne $S10, "--", rx1026_fail
+    add rx1026_pos, 2
+    set_addr $I10, rxcap_1031_fail
+    ($I12, $I11) = rx1026_cur."!mark_peek"($I10)
+    rx1026_cur."!cursor_pos"($I11)
+    ($P10) = rx1026_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1026_pos, "")
+    rx1026_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1063_done
-  rxcap_1063_fail:
-    goto rx1058_fail
-  rxcap_1063_done:
+    goto rxcap_1031_done
+  rxcap_1031_fail:
+    goto rx1026_fail
+  rxcap_1031_done:
   # rx subrule "O" subtype=capture negate=
-    rx1058_cur."!cursor_pos"(rx1058_pos)
-    $P10 = rx1058_cur."O"("%autoincrement")
-    unless $P10, rx1058_fail
-    rx1058_cur."!mark_push"(0, -1, 0, $P10)
+    rx1026_cur."!cursor_pos"(rx1026_pos)
+    $P10 = rx1026_cur."O"("%autoincrement")
+    unless $P10, rx1026_fail
+    rx1026_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1058_pos = $P10."pos"()
+    rx1026_pos = $P10."pos"()
   # rx pass
-    rx1058_cur."!cursor_pass"(rx1058_pos, "postfix:sym<-->")
-    rx1058_cur."!cursor_debug"("PASS  ", "postfix:sym<-->", " at pos=", rx1058_pos)
-    .return (rx1058_cur)
-  rx1058_fail:
+    rx1026_cur."!cursor_pass"(rx1026_pos, "postfix:sym<-->")
+    rx1026_cur."!cursor_debug"("PASS  ", "postfix:sym<-->", " at pos=", rx1026_pos)
+    .return (rx1026_cur)
+  rx1026_restart:
 .annotate 'line', 447
-    (rx1058_rep, rx1058_pos, $I10, $P10) = rx1058_cur."!mark_fail"(0)
-    lt rx1058_pos, -1, rx1058_done
-    eq rx1058_pos, -1, rx1058_fail
+    rx1026_cur."!cursor_debug"("NEXT ", "postfix:sym<-->")
+  rx1026_fail:
+    (rx1026_rep, rx1026_pos, $I10, $P10) = rx1026_cur."!mark_fail"(0)
+    lt rx1026_pos, -1, rx1026_done
+    eq rx1026_pos, -1, rx1026_fail
     jump $I10
-  rx1058_done:
-    rx1058_cur."!cursor_fail"()
-    rx1058_cur."!cursor_debug"("FAIL  ", "postfix:sym<-->")
-    .return (rx1058_cur)
+  rx1026_done:
+    rx1026_cur."!cursor_fail"()
+    rx1026_cur."!cursor_debug"("FAIL  ", "postfix:sym<-->")
+    .return (rx1026_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__postfix:sym<-->"  :subid("261_1278500537.15927") :method
+.sub "!PREFIX__postfix:sym<-->"  :subid("261_1279529226.73787") :method
 .annotate 'line', 447
-    $P1060 = self."!PREFIX__!subrule"("O", "--")
-    new $P1061, "ResizablePMCArray"
-    push $P1061, $P1060
-    .return ($P1061)
+    $P1028 = self."!PREFIX__!subrule"("O", "--")
+    new $P1029, "ResizablePMCArray"
+    push $P1029, $P1028
+    .return ($P1029)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<**>"  :subid("262_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<**>"  :subid("262_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1065_tgt
-    .local int rx1065_pos
-    .local int rx1065_off
-    .local int rx1065_eos
-    .local int rx1065_rep
-    .local pmc rx1065_cur
-    (rx1065_cur, rx1065_pos, rx1065_tgt) = self."!cursor_start"()
-    rx1065_cur."!cursor_debug"("START ", "infix:sym<**>")
-    .lex unicode:"$\x{a2}", rx1065_cur
+    .local string rx1033_tgt
+    .local int rx1033_pos
+    .local int rx1033_off
+    .local int rx1033_eos
+    .local int rx1033_rep
+    .local pmc rx1033_cur
+    (rx1033_cur, rx1033_pos, rx1033_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1033_cur
     .local pmc match
     .lex "$/", match
-    length rx1065_eos, rx1065_tgt
-    gt rx1065_pos, rx1065_eos, rx1065_done
-    set rx1065_off, 0
-    lt rx1065_pos, 2, rx1065_start
-    sub rx1065_off, rx1065_pos, 1
-    substr rx1065_tgt, rx1065_tgt, rx1065_off
-  rx1065_start:
+    length rx1033_eos, rx1033_tgt
+    gt rx1033_pos, rx1033_eos, rx1033_done
+    set rx1033_off, 0
+    lt rx1033_pos, 2, rx1033_start
+    sub rx1033_off, rx1033_pos, 1
+    substr rx1033_tgt, rx1033_tgt, rx1033_off
+  rx1033_start:
+    eq $I10, 1, rx1033_restart
+    rx1033_cur."!cursor_debug"("START ", "infix:sym<**>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1069_done
-    goto rxscan1069_scan
-  rxscan1069_loop:
-    ($P10) = rx1065_cur."from"()
+    ne $I10, -1, rxscan1037_done
+    goto rxscan1037_scan
+  rxscan1037_loop:
+    ($P10) = rx1033_cur."from"()
     inc $P10
-    set rx1065_pos, $P10
-    ge rx1065_pos, rx1065_eos, rxscan1069_done
-  rxscan1069_scan:
-    set_addr $I10, rxscan1069_loop
-    rx1065_cur."!mark_push"(0, rx1065_pos, $I10)
-  rxscan1069_done:
+    set rx1033_pos, $P10
+    ge rx1033_pos, rx1033_eos, rxscan1037_done
+  rxscan1037_scan:
+    set_addr $I10, rxscan1037_loop
+    rx1033_cur."!mark_push"(0, rx1033_pos, $I10)
+  rxscan1037_done:
 .annotate 'line', 498
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1070_fail
-    rx1065_cur."!mark_push"(0, rx1065_pos, $I10)
+    set_addr $I10, rxcap_1038_fail
+    rx1033_cur."!mark_push"(0, rx1033_pos, $I10)
   # rx literal  "**"
-    add $I11, rx1065_pos, 2
-    gt $I11, rx1065_eos, rx1065_fail
-    sub $I11, rx1065_pos, rx1065_off
-    substr $S10, rx1065_tgt, $I11, 2
-    ne $S10, "**", rx1065_fail
-    add rx1065_pos, 2
-    set_addr $I10, rxcap_1070_fail
-    ($I12, $I11) = rx1065_cur."!mark_peek"($I10)
-    rx1065_cur."!cursor_pos"($I11)
-    ($P10) = rx1065_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1065_pos, "")
-    rx1065_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1033_pos, 2
+    gt $I11, rx1033_eos, rx1033_fail
+    sub $I11, rx1033_pos, rx1033_off
+    substr $S10, rx1033_tgt, $I11, 2
+    ne $S10, "**", rx1033_fail
+    add rx1033_pos, 2
+    set_addr $I10, rxcap_1038_fail
+    ($I12, $I11) = rx1033_cur."!mark_peek"($I10)
+    rx1033_cur."!cursor_pos"($I11)
+    ($P10) = rx1033_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1033_pos, "")
+    rx1033_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1070_done
-  rxcap_1070_fail:
-    goto rx1065_fail
-  rxcap_1070_done:
+    goto rxcap_1038_done
+  rxcap_1038_fail:
+    goto rx1033_fail
+  rxcap_1038_done:
   # rx subrule "O" subtype=capture negate=
-    rx1065_cur."!cursor_pos"(rx1065_pos)
-    $P10 = rx1065_cur."O"("%exponentiation, :pirop<pow>")
-    unless $P10, rx1065_fail
-    rx1065_cur."!mark_push"(0, -1, 0, $P10)
+    rx1033_cur."!cursor_pos"(rx1033_pos)
+    $P10 = rx1033_cur."O"("%exponentiation, :pirop<pow>")
+    unless $P10, rx1033_fail
+    rx1033_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1065_pos = $P10."pos"()
+    rx1033_pos = $P10."pos"()
   # rx pass
-    rx1065_cur."!cursor_pass"(rx1065_pos, "infix:sym<**>")
-    rx1065_cur."!cursor_debug"("PASS  ", "infix:sym<**>", " at pos=", rx1065_pos)
-    .return (rx1065_cur)
-  rx1065_fail:
+    rx1033_cur."!cursor_pass"(rx1033_pos, "infix:sym<**>")
+    rx1033_cur."!cursor_debug"("PASS  ", "infix:sym<**>", " at pos=", rx1033_pos)
+    .return (rx1033_cur)
+  rx1033_restart:
 .annotate 'line', 447
-    (rx1065_rep, rx1065_pos, $I10, $P10) = rx1065_cur."!mark_fail"(0)
-    lt rx1065_pos, -1, rx1065_done
-    eq rx1065_pos, -1, rx1065_fail
+    rx1033_cur."!cursor_debug"("NEXT ", "infix:sym<**>")
+  rx1033_fail:
+    (rx1033_rep, rx1033_pos, $I10, $P10) = rx1033_cur."!mark_fail"(0)
+    lt rx1033_pos, -1, rx1033_done
+    eq rx1033_pos, -1, rx1033_fail
     jump $I10
-  rx1065_done:
-    rx1065_cur."!cursor_fail"()
-    rx1065_cur."!cursor_debug"("FAIL  ", "infix:sym<**>")
-    .return (rx1065_cur)
+  rx1033_done:
+    rx1033_cur."!cursor_fail"()
+    rx1033_cur."!cursor_debug"("FAIL  ", "infix:sym<**>")
+    .return (rx1033_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<**>"  :subid("263_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<**>"  :subid("263_1279529226.73787") :method
 .annotate 'line', 447
-    $P1067 = self."!PREFIX__!subrule"("O", "**")
-    new $P1068, "ResizablePMCArray"
-    push $P1068, $P1067
-    .return ($P1068)
+    $P1035 = self."!PREFIX__!subrule"("O", "**")
+    new $P1036, "ResizablePMCArray"
+    push $P1036, $P1035
+    .return ($P1036)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<+>"  :subid("264_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<+>"  :subid("264_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1072_tgt
-    .local int rx1072_pos
-    .local int rx1072_off
-    .local int rx1072_eos
-    .local int rx1072_rep
-    .local pmc rx1072_cur
-    (rx1072_cur, rx1072_pos, rx1072_tgt) = self."!cursor_start"()
-    rx1072_cur."!cursor_debug"("START ", "prefix:sym<+>")
-    .lex unicode:"$\x{a2}", rx1072_cur
+    .local string rx1040_tgt
+    .local int rx1040_pos
+    .local int rx1040_off
+    .local int rx1040_eos
+    .local int rx1040_rep
+    .local pmc rx1040_cur
+    (rx1040_cur, rx1040_pos, rx1040_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1040_cur
     .local pmc match
     .lex "$/", match
-    length rx1072_eos, rx1072_tgt
-    gt rx1072_pos, rx1072_eos, rx1072_done
-    set rx1072_off, 0
-    lt rx1072_pos, 2, rx1072_start
-    sub rx1072_off, rx1072_pos, 1
-    substr rx1072_tgt, rx1072_tgt, rx1072_off
-  rx1072_start:
+    length rx1040_eos, rx1040_tgt
+    gt rx1040_pos, rx1040_eos, rx1040_done
+    set rx1040_off, 0
+    lt rx1040_pos, 2, rx1040_start
+    sub rx1040_off, rx1040_pos, 1
+    substr rx1040_tgt, rx1040_tgt, rx1040_off
+  rx1040_start:
+    eq $I10, 1, rx1040_restart
+    rx1040_cur."!cursor_debug"("START ", "prefix:sym<+>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1076_done
-    goto rxscan1076_scan
-  rxscan1076_loop:
-    ($P10) = rx1072_cur."from"()
+    ne $I10, -1, rxscan1044_done
+    goto rxscan1044_scan
+  rxscan1044_loop:
+    ($P10) = rx1040_cur."from"()
     inc $P10
-    set rx1072_pos, $P10
-    ge rx1072_pos, rx1072_eos, rxscan1076_done
-  rxscan1076_scan:
-    set_addr $I10, rxscan1076_loop
-    rx1072_cur."!mark_push"(0, rx1072_pos, $I10)
-  rxscan1076_done:
+    set rx1040_pos, $P10
+    ge rx1040_pos, rx1040_eos, rxscan1044_done
+  rxscan1044_scan:
+    set_addr $I10, rxscan1044_loop
+    rx1040_cur."!mark_push"(0, rx1040_pos, $I10)
+  rxscan1044_done:
 .annotate 'line', 500
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1077_fail
-    rx1072_cur."!mark_push"(0, rx1072_pos, $I10)
+    set_addr $I10, rxcap_1045_fail
+    rx1040_cur."!mark_push"(0, rx1040_pos, $I10)
   # rx literal  "+"
-    add $I11, rx1072_pos, 1
-    gt $I11, rx1072_eos, rx1072_fail
-    sub $I11, rx1072_pos, rx1072_off
-    substr $S10, rx1072_tgt, $I11, 1
-    ne $S10, "+", rx1072_fail
-    add rx1072_pos, 1
-    set_addr $I10, rxcap_1077_fail
-    ($I12, $I11) = rx1072_cur."!mark_peek"($I10)
-    rx1072_cur."!cursor_pos"($I11)
-    ($P10) = rx1072_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1072_pos, "")
-    rx1072_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1040_pos, 1
+    gt $I11, rx1040_eos, rx1040_fail
+    sub $I11, rx1040_pos, rx1040_off
+    substr $S10, rx1040_tgt, $I11, 1
+    ne $S10, "+", rx1040_fail
+    add rx1040_pos, 1
+    set_addr $I10, rxcap_1045_fail
+    ($I12, $I11) = rx1040_cur."!mark_peek"($I10)
+    rx1040_cur."!cursor_pos"($I11)
+    ($P10) = rx1040_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1040_pos, "")
+    rx1040_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1077_done
-  rxcap_1077_fail:
-    goto rx1072_fail
-  rxcap_1077_done:
+    goto rxcap_1045_done
+  rxcap_1045_fail:
+    goto rx1040_fail
+  rxcap_1045_done:
   # rx subrule "O" subtype=capture negate=
-    rx1072_cur."!cursor_pos"(rx1072_pos)
-    $P10 = rx1072_cur."O"("%symbolic_unary, :pirop<set N*>")
-    unless $P10, rx1072_fail
-    rx1072_cur."!mark_push"(0, -1, 0, $P10)
+    rx1040_cur."!cursor_pos"(rx1040_pos)
+    $P10 = rx1040_cur."O"("%symbolic_unary, :pirop<set N*>")
+    unless $P10, rx1040_fail
+    rx1040_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1072_pos = $P10."pos"()
+    rx1040_pos = $P10."pos"()
   # rx pass
-    rx1072_cur."!cursor_pass"(rx1072_pos, "prefix:sym<+>")
-    rx1072_cur."!cursor_debug"("PASS  ", "prefix:sym<+>", " at pos=", rx1072_pos)
-    .return (rx1072_cur)
-  rx1072_fail:
+    rx1040_cur."!cursor_pass"(rx1040_pos, "prefix:sym<+>")
+    rx1040_cur."!cursor_debug"("PASS  ", "prefix:sym<+>", " at pos=", rx1040_pos)
+    .return (rx1040_cur)
+  rx1040_restart:
 .annotate 'line', 447
-    (rx1072_rep, rx1072_pos, $I10, $P10) = rx1072_cur."!mark_fail"(0)
-    lt rx1072_pos, -1, rx1072_done
-    eq rx1072_pos, -1, rx1072_fail
+    rx1040_cur."!cursor_debug"("NEXT ", "prefix:sym<+>")
+  rx1040_fail:
+    (rx1040_rep, rx1040_pos, $I10, $P10) = rx1040_cur."!mark_fail"(0)
+    lt rx1040_pos, -1, rx1040_done
+    eq rx1040_pos, -1, rx1040_fail
     jump $I10
-  rx1072_done:
-    rx1072_cur."!cursor_fail"()
-    rx1072_cur."!cursor_debug"("FAIL  ", "prefix:sym<+>")
-    .return (rx1072_cur)
+  rx1040_done:
+    rx1040_cur."!cursor_fail"()
+    rx1040_cur."!cursor_debug"("FAIL  ", "prefix:sym<+>")
+    .return (rx1040_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<+>"  :subid("265_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<+>"  :subid("265_1279529226.73787") :method
 .annotate 'line', 447
-    $P1074 = self."!PREFIX__!subrule"("O", "+")
-    new $P1075, "ResizablePMCArray"
-    push $P1075, $P1074
-    .return ($P1075)
+    $P1042 = self."!PREFIX__!subrule"("O", "+")
+    new $P1043, "ResizablePMCArray"
+    push $P1043, $P1042
+    .return ($P1043)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<~>"  :subid("266_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<~>"  :subid("266_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1079_tgt
-    .local int rx1079_pos
-    .local int rx1079_off
-    .local int rx1079_eos
-    .local int rx1079_rep
-    .local pmc rx1079_cur
-    (rx1079_cur, rx1079_pos, rx1079_tgt) = self."!cursor_start"()
-    rx1079_cur."!cursor_debug"("START ", "prefix:sym<~>")
-    .lex unicode:"$\x{a2}", rx1079_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1079_eos, rx1079_tgt
-    gt rx1079_pos, rx1079_eos, rx1079_done
-    set rx1079_off, 0
-    lt rx1079_pos, 2, rx1079_start
-    sub rx1079_off, rx1079_pos, 1
-    substr rx1079_tgt, rx1079_tgt, rx1079_off
-  rx1079_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1083_done
-    goto rxscan1083_scan
-  rxscan1083_loop:
-    ($P10) = rx1079_cur."from"()
-    inc $P10
-    set rx1079_pos, $P10
-    ge rx1079_pos, rx1079_eos, rxscan1083_done
-  rxscan1083_scan:
-    set_addr $I10, rxscan1083_loop
-    rx1079_cur."!mark_push"(0, rx1079_pos, $I10)
-  rxscan1083_done:
+    .local string rx1047_tgt
+    .local int rx1047_pos
+    .local int rx1047_off
+    .local int rx1047_eos
+    .local int rx1047_rep
+    .local pmc rx1047_cur
+    (rx1047_cur, rx1047_pos, rx1047_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1047_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1047_eos, rx1047_tgt
+    gt rx1047_pos, rx1047_eos, rx1047_done
+    set rx1047_off, 0
+    lt rx1047_pos, 2, rx1047_start
+    sub rx1047_off, rx1047_pos, 1
+    substr rx1047_tgt, rx1047_tgt, rx1047_off
+  rx1047_start:
+    eq $I10, 1, rx1047_restart
+    rx1047_cur."!cursor_debug"("START ", "prefix:sym<~>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1051_done
+    goto rxscan1051_scan
+  rxscan1051_loop:
+    ($P10) = rx1047_cur."from"()
+    inc $P10
+    set rx1047_pos, $P10
+    ge rx1047_pos, rx1047_eos, rxscan1051_done
+  rxscan1051_scan:
+    set_addr $I10, rxscan1051_loop
+    rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
+  rxscan1051_done:
 .annotate 'line', 501
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1084_fail
-    rx1079_cur."!mark_push"(0, rx1079_pos, $I10)
+    set_addr $I10, rxcap_1052_fail
+    rx1047_cur."!mark_push"(0, rx1047_pos, $I10)
   # rx literal  "~"
-    add $I11, rx1079_pos, 1
-    gt $I11, rx1079_eos, rx1079_fail
-    sub $I11, rx1079_pos, rx1079_off
-    substr $S10, rx1079_tgt, $I11, 1
-    ne $S10, "~", rx1079_fail
-    add rx1079_pos, 1
-    set_addr $I10, rxcap_1084_fail
-    ($I12, $I11) = rx1079_cur."!mark_peek"($I10)
-    rx1079_cur."!cursor_pos"($I11)
-    ($P10) = rx1079_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1079_pos, "")
-    rx1079_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1047_pos, 1
+    gt $I11, rx1047_eos, rx1047_fail
+    sub $I11, rx1047_pos, rx1047_off
+    substr $S10, rx1047_tgt, $I11, 1
+    ne $S10, "~", rx1047_fail
+    add rx1047_pos, 1
+    set_addr $I10, rxcap_1052_fail
+    ($I12, $I11) = rx1047_cur."!mark_peek"($I10)
+    rx1047_cur."!cursor_pos"($I11)
+    ($P10) = rx1047_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1047_pos, "")
+    rx1047_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1084_done
-  rxcap_1084_fail:
-    goto rx1079_fail
-  rxcap_1084_done:
+    goto rxcap_1052_done
+  rxcap_1052_fail:
+    goto rx1047_fail
+  rxcap_1052_done:
   # rx subrule "O" subtype=capture negate=
-    rx1079_cur."!cursor_pos"(rx1079_pos)
-    $P10 = rx1079_cur."O"("%symbolic_unary, :pirop<set S*>")
-    unless $P10, rx1079_fail
-    rx1079_cur."!mark_push"(0, -1, 0, $P10)
+    rx1047_cur."!cursor_pos"(rx1047_pos)
+    $P10 = rx1047_cur."O"("%symbolic_unary, :pirop<set S*>")
+    unless $P10, rx1047_fail
+    rx1047_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1079_pos = $P10."pos"()
+    rx1047_pos = $P10."pos"()
   # rx pass
-    rx1079_cur."!cursor_pass"(rx1079_pos, "prefix:sym<~>")
-    rx1079_cur."!cursor_debug"("PASS  ", "prefix:sym<~>", " at pos=", rx1079_pos)
-    .return (rx1079_cur)
-  rx1079_fail:
+    rx1047_cur."!cursor_pass"(rx1047_pos, "prefix:sym<~>")
+    rx1047_cur."!cursor_debug"("PASS  ", "prefix:sym<~>", " at pos=", rx1047_pos)
+    .return (rx1047_cur)
+  rx1047_restart:
 .annotate 'line', 447
-    (rx1079_rep, rx1079_pos, $I10, $P10) = rx1079_cur."!mark_fail"(0)
-    lt rx1079_pos, -1, rx1079_done
-    eq rx1079_pos, -1, rx1079_fail
+    rx1047_cur."!cursor_debug"("NEXT ", "prefix:sym<~>")
+  rx1047_fail:
+    (rx1047_rep, rx1047_pos, $I10, $P10) = rx1047_cur."!mark_fail"(0)
+    lt rx1047_pos, -1, rx1047_done
+    eq rx1047_pos, -1, rx1047_fail
     jump $I10
-  rx1079_done:
-    rx1079_cur."!cursor_fail"()
-    rx1079_cur."!cursor_debug"("FAIL  ", "prefix:sym<~>")
-    .return (rx1079_cur)
+  rx1047_done:
+    rx1047_cur."!cursor_fail"()
+    rx1047_cur."!cursor_debug"("FAIL  ", "prefix:sym<~>")
+    .return (rx1047_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<~>"  :subid("267_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<~>"  :subid("267_1279529226.73787") :method
 .annotate 'line', 447
-    $P1081 = self."!PREFIX__!subrule"("O", "~")
-    new $P1082, "ResizablePMCArray"
-    push $P1082, $P1081
-    .return ($P1082)
+    $P1049 = self."!PREFIX__!subrule"("O", "~")
+    new $P1050, "ResizablePMCArray"
+    push $P1050, $P1049
+    .return ($P1050)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<->"  :subid("268_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<->"  :subid("268_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1086_tgt
-    .local int rx1086_pos
-    .local int rx1086_off
-    .local int rx1086_eos
-    .local int rx1086_rep
-    .local pmc rx1086_cur
-    (rx1086_cur, rx1086_pos, rx1086_tgt) = self."!cursor_start"()
-    rx1086_cur."!cursor_debug"("START ", "prefix:sym<->")
-    .lex unicode:"$\x{a2}", rx1086_cur
+    .local string rx1054_tgt
+    .local int rx1054_pos
+    .local int rx1054_off
+    .local int rx1054_eos
+    .local int rx1054_rep
+    .local pmc rx1054_cur
+    (rx1054_cur, rx1054_pos, rx1054_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1054_cur
     .local pmc match
     .lex "$/", match
-    length rx1086_eos, rx1086_tgt
-    gt rx1086_pos, rx1086_eos, rx1086_done
-    set rx1086_off, 0
-    lt rx1086_pos, 2, rx1086_start
-    sub rx1086_off, rx1086_pos, 1
-    substr rx1086_tgt, rx1086_tgt, rx1086_off
-  rx1086_start:
+    length rx1054_eos, rx1054_tgt
+    gt rx1054_pos, rx1054_eos, rx1054_done
+    set rx1054_off, 0
+    lt rx1054_pos, 2, rx1054_start
+    sub rx1054_off, rx1054_pos, 1
+    substr rx1054_tgt, rx1054_tgt, rx1054_off
+  rx1054_start:
+    eq $I10, 1, rx1054_restart
+    rx1054_cur."!cursor_debug"("START ", "prefix:sym<->")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1089_done
-    goto rxscan1089_scan
-  rxscan1089_loop:
-    ($P10) = rx1086_cur."from"()
+    ne $I10, -1, rxscan1057_done
+    goto rxscan1057_scan
+  rxscan1057_loop:
+    ($P10) = rx1054_cur."from"()
     inc $P10
-    set rx1086_pos, $P10
-    ge rx1086_pos, rx1086_eos, rxscan1089_done
-  rxscan1089_scan:
-    set_addr $I10, rxscan1089_loop
-    rx1086_cur."!mark_push"(0, rx1086_pos, $I10)
-  rxscan1089_done:
+    set rx1054_pos, $P10
+    ge rx1054_pos, rx1054_eos, rxscan1057_done
+  rxscan1057_scan:
+    set_addr $I10, rxscan1057_loop
+    rx1054_cur."!mark_push"(0, rx1054_pos, $I10)
+  rxscan1057_done:
 .annotate 'line', 502
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1090_fail
-    rx1086_cur."!mark_push"(0, rx1086_pos, $I10)
+    set_addr $I10, rxcap_1058_fail
+    rx1054_cur."!mark_push"(0, rx1054_pos, $I10)
   # rx literal  "-"
-    add $I11, rx1086_pos, 1
-    gt $I11, rx1086_eos, rx1086_fail
-    sub $I11, rx1086_pos, rx1086_off
-    substr $S10, rx1086_tgt, $I11, 1
-    ne $S10, "-", rx1086_fail
-    add rx1086_pos, 1
-    set_addr $I10, rxcap_1090_fail
-    ($I12, $I11) = rx1086_cur."!mark_peek"($I10)
-    rx1086_cur."!cursor_pos"($I11)
-    ($P10) = rx1086_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1086_pos, "")
-    rx1086_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1054_pos, 1
+    gt $I11, rx1054_eos, rx1054_fail
+    sub $I11, rx1054_pos, rx1054_off
+    substr $S10, rx1054_tgt, $I11, 1
+    ne $S10, "-", rx1054_fail
+    add rx1054_pos, 1
+    set_addr $I10, rxcap_1058_fail
+    ($I12, $I11) = rx1054_cur."!mark_peek"($I10)
+    rx1054_cur."!cursor_pos"($I11)
+    ($P10) = rx1054_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1054_pos, "")
+    rx1054_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1090_done
-  rxcap_1090_fail:
-    goto rx1086_fail
-  rxcap_1090_done:
+    goto rxcap_1058_done
+  rxcap_1058_fail:
+    goto rx1054_fail
+  rxcap_1058_done:
   # rx enumcharlist negate=1 zerowidth
-    ge rx1086_pos, rx1086_eos, rx1086_fail
-    sub $I10, rx1086_pos, rx1086_off
-    substr $S10, rx1086_tgt, $I10, 1
+    ge rx1054_pos, rx1054_eos, rx1054_fail
+    sub $I10, rx1054_pos, rx1054_off
+    substr $S10, rx1054_tgt, $I10, 1
     index $I11, ">", $S10
-    ge $I11, 0, rx1086_fail
+    ge $I11, 0, rx1054_fail
   # rx subrule "number" subtype=zerowidth negate=1
-    rx1086_cur."!cursor_pos"(rx1086_pos)
-    $P10 = rx1086_cur."number"()
-    if $P10, rx1086_fail
+    rx1054_cur."!cursor_pos"(rx1054_pos)
+    $P10 = rx1054_cur."number"()
+    if $P10, rx1054_fail
   # rx subrule "O" subtype=capture negate=
-    rx1086_cur."!cursor_pos"(rx1086_pos)
-    $P10 = rx1086_cur."O"("%symbolic_unary, :pirop<neg>")
-    unless $P10, rx1086_fail
-    rx1086_cur."!mark_push"(0, -1, 0, $P10)
+    rx1054_cur."!cursor_pos"(rx1054_pos)
+    $P10 = rx1054_cur."O"("%symbolic_unary, :pirop<neg>")
+    unless $P10, rx1054_fail
+    rx1054_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1086_pos = $P10."pos"()
+    rx1054_pos = $P10."pos"()
   # rx pass
-    rx1086_cur."!cursor_pass"(rx1086_pos, "prefix:sym<->")
-    rx1086_cur."!cursor_debug"("PASS  ", "prefix:sym<->", " at pos=", rx1086_pos)
-    .return (rx1086_cur)
-  rx1086_fail:
+    rx1054_cur."!cursor_pass"(rx1054_pos, "prefix:sym<->")
+    rx1054_cur."!cursor_debug"("PASS  ", "prefix:sym<->", " at pos=", rx1054_pos)
+    .return (rx1054_cur)
+  rx1054_restart:
 .annotate 'line', 447
-    (rx1086_rep, rx1086_pos, $I10, $P10) = rx1086_cur."!mark_fail"(0)
-    lt rx1086_pos, -1, rx1086_done
-    eq rx1086_pos, -1, rx1086_fail
+    rx1054_cur."!cursor_debug"("NEXT ", "prefix:sym<->")
+  rx1054_fail:
+    (rx1054_rep, rx1054_pos, $I10, $P10) = rx1054_cur."!mark_fail"(0)
+    lt rx1054_pos, -1, rx1054_done
+    eq rx1054_pos, -1, rx1054_fail
     jump $I10
-  rx1086_done:
-    rx1086_cur."!cursor_fail"()
-    rx1086_cur."!cursor_debug"("FAIL  ", "prefix:sym<->")
-    .return (rx1086_cur)
+  rx1054_done:
+    rx1054_cur."!cursor_fail"()
+    rx1054_cur."!cursor_debug"("FAIL  ", "prefix:sym<->")
+    .return (rx1054_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<->"  :subid("269_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<->"  :subid("269_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1088, "ResizablePMCArray"
-    push $P1088, "-"
-    .return ($P1088)
+    new $P1056, "ResizablePMCArray"
+    push $P1056, "-"
+    .return ($P1056)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<?>"  :subid("270_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<?>"  :subid("270_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1092_tgt
-    .local int rx1092_pos
-    .local int rx1092_off
-    .local int rx1092_eos
-    .local int rx1092_rep
-    .local pmc rx1092_cur
-    (rx1092_cur, rx1092_pos, rx1092_tgt) = self."!cursor_start"()
-    rx1092_cur."!cursor_debug"("START ", "prefix:sym<?>")
-    .lex unicode:"$\x{a2}", rx1092_cur
+    .local string rx1060_tgt
+    .local int rx1060_pos
+    .local int rx1060_off
+    .local int rx1060_eos
+    .local int rx1060_rep
+    .local pmc rx1060_cur
+    (rx1060_cur, rx1060_pos, rx1060_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1060_cur
     .local pmc match
     .lex "$/", match
-    length rx1092_eos, rx1092_tgt
-    gt rx1092_pos, rx1092_eos, rx1092_done
-    set rx1092_off, 0
-    lt rx1092_pos, 2, rx1092_start
-    sub rx1092_off, rx1092_pos, 1
-    substr rx1092_tgt, rx1092_tgt, rx1092_off
-  rx1092_start:
+    length rx1060_eos, rx1060_tgt
+    gt rx1060_pos, rx1060_eos, rx1060_done
+    set rx1060_off, 0
+    lt rx1060_pos, 2, rx1060_start
+    sub rx1060_off, rx1060_pos, 1
+    substr rx1060_tgt, rx1060_tgt, rx1060_off
+  rx1060_start:
+    eq $I10, 1, rx1060_restart
+    rx1060_cur."!cursor_debug"("START ", "prefix:sym<?>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1096_done
-    goto rxscan1096_scan
-  rxscan1096_loop:
-    ($P10) = rx1092_cur."from"()
+    ne $I10, -1, rxscan1064_done
+    goto rxscan1064_scan
+  rxscan1064_loop:
+    ($P10) = rx1060_cur."from"()
     inc $P10
-    set rx1092_pos, $P10
-    ge rx1092_pos, rx1092_eos, rxscan1096_done
-  rxscan1096_scan:
-    set_addr $I10, rxscan1096_loop
-    rx1092_cur."!mark_push"(0, rx1092_pos, $I10)
-  rxscan1096_done:
+    set rx1060_pos, $P10
+    ge rx1060_pos, rx1060_eos, rxscan1064_done
+  rxscan1064_scan:
+    set_addr $I10, rxscan1064_loop
+    rx1060_cur."!mark_push"(0, rx1060_pos, $I10)
+  rxscan1064_done:
 .annotate 'line', 503
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1097_fail
-    rx1092_cur."!mark_push"(0, rx1092_pos, $I10)
+    set_addr $I10, rxcap_1065_fail
+    rx1060_cur."!mark_push"(0, rx1060_pos, $I10)
   # rx literal  "?"
-    add $I11, rx1092_pos, 1
-    gt $I11, rx1092_eos, rx1092_fail
-    sub $I11, rx1092_pos, rx1092_off
-    substr $S10, rx1092_tgt, $I11, 1
-    ne $S10, "?", rx1092_fail
-    add rx1092_pos, 1
-    set_addr $I10, rxcap_1097_fail
-    ($I12, $I11) = rx1092_cur."!mark_peek"($I10)
-    rx1092_cur."!cursor_pos"($I11)
-    ($P10) = rx1092_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1092_pos, "")
-    rx1092_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1060_pos, 1
+    gt $I11, rx1060_eos, rx1060_fail
+    sub $I11, rx1060_pos, rx1060_off
+    substr $S10, rx1060_tgt, $I11, 1
+    ne $S10, "?", rx1060_fail
+    add rx1060_pos, 1
+    set_addr $I10, rxcap_1065_fail
+    ($I12, $I11) = rx1060_cur."!mark_peek"($I10)
+    rx1060_cur."!cursor_pos"($I11)
+    ($P10) = rx1060_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1060_pos, "")
+    rx1060_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1097_done
-  rxcap_1097_fail:
-    goto rx1092_fail
-  rxcap_1097_done:
+    goto rxcap_1065_done
+  rxcap_1065_fail:
+    goto rx1060_fail
+  rxcap_1065_done:
   # rx subrule "O" subtype=capture negate=
-    rx1092_cur."!cursor_pos"(rx1092_pos)
-    $P10 = rx1092_cur."O"("%symbolic_unary, :pirop<istrue>")
-    unless $P10, rx1092_fail
-    rx1092_cur."!mark_push"(0, -1, 0, $P10)
+    rx1060_cur."!cursor_pos"(rx1060_pos)
+    $P10 = rx1060_cur."O"("%symbolic_unary, :pirop<istrue>")
+    unless $P10, rx1060_fail
+    rx1060_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1092_pos = $P10."pos"()
+    rx1060_pos = $P10."pos"()
   # rx pass
-    rx1092_cur."!cursor_pass"(rx1092_pos, "prefix:sym<?>")
-    rx1092_cur."!cursor_debug"("PASS  ", "prefix:sym<?>", " at pos=", rx1092_pos)
-    .return (rx1092_cur)
-  rx1092_fail:
+    rx1060_cur."!cursor_pass"(rx1060_pos, "prefix:sym<?>")
+    rx1060_cur."!cursor_debug"("PASS  ", "prefix:sym<?>", " at pos=", rx1060_pos)
+    .return (rx1060_cur)
+  rx1060_restart:
 .annotate 'line', 447
-    (rx1092_rep, rx1092_pos, $I10, $P10) = rx1092_cur."!mark_fail"(0)
-    lt rx1092_pos, -1, rx1092_done
-    eq rx1092_pos, -1, rx1092_fail
+    rx1060_cur."!cursor_debug"("NEXT ", "prefix:sym<?>")
+  rx1060_fail:
+    (rx1060_rep, rx1060_pos, $I10, $P10) = rx1060_cur."!mark_fail"(0)
+    lt rx1060_pos, -1, rx1060_done
+    eq rx1060_pos, -1, rx1060_fail
     jump $I10
-  rx1092_done:
-    rx1092_cur."!cursor_fail"()
-    rx1092_cur."!cursor_debug"("FAIL  ", "prefix:sym<?>")
-    .return (rx1092_cur)
+  rx1060_done:
+    rx1060_cur."!cursor_fail"()
+    rx1060_cur."!cursor_debug"("FAIL  ", "prefix:sym<?>")
+    .return (rx1060_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<?>"  :subid("271_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<?>"  :subid("271_1279529226.73787") :method
 .annotate 'line', 447
-    $P1094 = self."!PREFIX__!subrule"("O", "?")
-    new $P1095, "ResizablePMCArray"
-    push $P1095, $P1094
-    .return ($P1095)
+    $P1062 = self."!PREFIX__!subrule"("O", "?")
+    new $P1063, "ResizablePMCArray"
+    push $P1063, $P1062
+    .return ($P1063)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<!>"  :subid("272_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<!>"  :subid("272_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1099_tgt
-    .local int rx1099_pos
-    .local int rx1099_off
-    .local int rx1099_eos
-    .local int rx1099_rep
-    .local pmc rx1099_cur
-    (rx1099_cur, rx1099_pos, rx1099_tgt) = self."!cursor_start"()
-    rx1099_cur."!cursor_debug"("START ", "prefix:sym<!>")
-    .lex unicode:"$\x{a2}", rx1099_cur
+    .local string rx1067_tgt
+    .local int rx1067_pos
+    .local int rx1067_off
+    .local int rx1067_eos
+    .local int rx1067_rep
+    .local pmc rx1067_cur
+    (rx1067_cur, rx1067_pos, rx1067_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1067_cur
     .local pmc match
     .lex "$/", match
-    length rx1099_eos, rx1099_tgt
-    gt rx1099_pos, rx1099_eos, rx1099_done
-    set rx1099_off, 0
-    lt rx1099_pos, 2, rx1099_start
-    sub rx1099_off, rx1099_pos, 1
-    substr rx1099_tgt, rx1099_tgt, rx1099_off
-  rx1099_start:
+    length rx1067_eos, rx1067_tgt
+    gt rx1067_pos, rx1067_eos, rx1067_done
+    set rx1067_off, 0
+    lt rx1067_pos, 2, rx1067_start
+    sub rx1067_off, rx1067_pos, 1
+    substr rx1067_tgt, rx1067_tgt, rx1067_off
+  rx1067_start:
+    eq $I10, 1, rx1067_restart
+    rx1067_cur."!cursor_debug"("START ", "prefix:sym<!>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1103_done
-    goto rxscan1103_scan
-  rxscan1103_loop:
-    ($P10) = rx1099_cur."from"()
+    ne $I10, -1, rxscan1071_done
+    goto rxscan1071_scan
+  rxscan1071_loop:
+    ($P10) = rx1067_cur."from"()
     inc $P10
-    set rx1099_pos, $P10
-    ge rx1099_pos, rx1099_eos, rxscan1103_done
-  rxscan1103_scan:
-    set_addr $I10, rxscan1103_loop
-    rx1099_cur."!mark_push"(0, rx1099_pos, $I10)
-  rxscan1103_done:
+    set rx1067_pos, $P10
+    ge rx1067_pos, rx1067_eos, rxscan1071_done
+  rxscan1071_scan:
+    set_addr $I10, rxscan1071_loop
+    rx1067_cur."!mark_push"(0, rx1067_pos, $I10)
+  rxscan1071_done:
 .annotate 'line', 504
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1104_fail
-    rx1099_cur."!mark_push"(0, rx1099_pos, $I10)
+    set_addr $I10, rxcap_1072_fail
+    rx1067_cur."!mark_push"(0, rx1067_pos, $I10)
   # rx literal  "!"
-    add $I11, rx1099_pos, 1
-    gt $I11, rx1099_eos, rx1099_fail
-    sub $I11, rx1099_pos, rx1099_off
-    substr $S10, rx1099_tgt, $I11, 1
-    ne $S10, "!", rx1099_fail
-    add rx1099_pos, 1
-    set_addr $I10, rxcap_1104_fail
-    ($I12, $I11) = rx1099_cur."!mark_peek"($I10)
-    rx1099_cur."!cursor_pos"($I11)
-    ($P10) = rx1099_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1099_pos, "")
-    rx1099_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1067_pos, 1
+    gt $I11, rx1067_eos, rx1067_fail
+    sub $I11, rx1067_pos, rx1067_off
+    substr $S10, rx1067_tgt, $I11, 1
+    ne $S10, "!", rx1067_fail
+    add rx1067_pos, 1
+    set_addr $I10, rxcap_1072_fail
+    ($I12, $I11) = rx1067_cur."!mark_peek"($I10)
+    rx1067_cur."!cursor_pos"($I11)
+    ($P10) = rx1067_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1067_pos, "")
+    rx1067_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1104_done
-  rxcap_1104_fail:
-    goto rx1099_fail
-  rxcap_1104_done:
+    goto rxcap_1072_done
+  rxcap_1072_fail:
+    goto rx1067_fail
+  rxcap_1072_done:
   # rx subrule "O" subtype=capture negate=
-    rx1099_cur."!cursor_pos"(rx1099_pos)
-    $P10 = rx1099_cur."O"("%symbolic_unary, :pirop<isfalse>")
-    unless $P10, rx1099_fail
-    rx1099_cur."!mark_push"(0, -1, 0, $P10)
+    rx1067_cur."!cursor_pos"(rx1067_pos)
+    $P10 = rx1067_cur."O"("%symbolic_unary, :pirop<isfalse>")
+    unless $P10, rx1067_fail
+    rx1067_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1099_pos = $P10."pos"()
+    rx1067_pos = $P10."pos"()
   # rx pass
-    rx1099_cur."!cursor_pass"(rx1099_pos, "prefix:sym<!>")
-    rx1099_cur."!cursor_debug"("PASS  ", "prefix:sym<!>", " at pos=", rx1099_pos)
-    .return (rx1099_cur)
-  rx1099_fail:
+    rx1067_cur."!cursor_pass"(rx1067_pos, "prefix:sym<!>")
+    rx1067_cur."!cursor_debug"("PASS  ", "prefix:sym<!>", " at pos=", rx1067_pos)
+    .return (rx1067_cur)
+  rx1067_restart:
 .annotate 'line', 447
-    (rx1099_rep, rx1099_pos, $I10, $P10) = rx1099_cur."!mark_fail"(0)
-    lt rx1099_pos, -1, rx1099_done
-    eq rx1099_pos, -1, rx1099_fail
+    rx1067_cur."!cursor_debug"("NEXT ", "prefix:sym<!>")
+  rx1067_fail:
+    (rx1067_rep, rx1067_pos, $I10, $P10) = rx1067_cur."!mark_fail"(0)
+    lt rx1067_pos, -1, rx1067_done
+    eq rx1067_pos, -1, rx1067_fail
     jump $I10
-  rx1099_done:
-    rx1099_cur."!cursor_fail"()
-    rx1099_cur."!cursor_debug"("FAIL  ", "prefix:sym<!>")
-    .return (rx1099_cur)
+  rx1067_done:
+    rx1067_cur."!cursor_fail"()
+    rx1067_cur."!cursor_debug"("FAIL  ", "prefix:sym<!>")
+    .return (rx1067_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<!>"  :subid("273_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<!>"  :subid("273_1279529226.73787") :method
 .annotate 'line', 447
-    $P1101 = self."!PREFIX__!subrule"("O", "!")
-    new $P1102, "ResizablePMCArray"
-    push $P1102, $P1101
-    .return ($P1102)
+    $P1069 = self."!PREFIX__!subrule"("O", "!")
+    new $P1070, "ResizablePMCArray"
+    push $P1070, $P1069
+    .return ($P1070)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<|>"  :subid("274_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<|>"  :subid("274_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1106_tgt
-    .local int rx1106_pos
-    .local int rx1106_off
-    .local int rx1106_eos
-    .local int rx1106_rep
-    .local pmc rx1106_cur
-    (rx1106_cur, rx1106_pos, rx1106_tgt) = self."!cursor_start"()
-    rx1106_cur."!cursor_debug"("START ", "prefix:sym<|>")
-    .lex unicode:"$\x{a2}", rx1106_cur
+    .local string rx1074_tgt
+    .local int rx1074_pos
+    .local int rx1074_off
+    .local int rx1074_eos
+    .local int rx1074_rep
+    .local pmc rx1074_cur
+    (rx1074_cur, rx1074_pos, rx1074_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1074_cur
     .local pmc match
     .lex "$/", match
-    length rx1106_eos, rx1106_tgt
-    gt rx1106_pos, rx1106_eos, rx1106_done
-    set rx1106_off, 0
-    lt rx1106_pos, 2, rx1106_start
-    sub rx1106_off, rx1106_pos, 1
-    substr rx1106_tgt, rx1106_tgt, rx1106_off
-  rx1106_start:
+    length rx1074_eos, rx1074_tgt
+    gt rx1074_pos, rx1074_eos, rx1074_done
+    set rx1074_off, 0
+    lt rx1074_pos, 2, rx1074_start
+    sub rx1074_off, rx1074_pos, 1
+    substr rx1074_tgt, rx1074_tgt, rx1074_off
+  rx1074_start:
+    eq $I10, 1, rx1074_restart
+    rx1074_cur."!cursor_debug"("START ", "prefix:sym<|>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1110_done
-    goto rxscan1110_scan
-  rxscan1110_loop:
-    ($P10) = rx1106_cur."from"()
+    ne $I10, -1, rxscan1078_done
+    goto rxscan1078_scan
+  rxscan1078_loop:
+    ($P10) = rx1074_cur."from"()
     inc $P10
-    set rx1106_pos, $P10
-    ge rx1106_pos, rx1106_eos, rxscan1110_done
-  rxscan1110_scan:
-    set_addr $I10, rxscan1110_loop
-    rx1106_cur."!mark_push"(0, rx1106_pos, $I10)
-  rxscan1110_done:
+    set rx1074_pos, $P10
+    ge rx1074_pos, rx1074_eos, rxscan1078_done
+  rxscan1078_scan:
+    set_addr $I10, rxscan1078_loop
+    rx1074_cur."!mark_push"(0, rx1074_pos, $I10)
+  rxscan1078_done:
 .annotate 'line', 505
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1111_fail
-    rx1106_cur."!mark_push"(0, rx1106_pos, $I10)
+    set_addr $I10, rxcap_1079_fail
+    rx1074_cur."!mark_push"(0, rx1074_pos, $I10)
   # rx literal  "|"
-    add $I11, rx1106_pos, 1
-    gt $I11, rx1106_eos, rx1106_fail
-    sub $I11, rx1106_pos, rx1106_off
-    substr $S10, rx1106_tgt, $I11, 1
-    ne $S10, "|", rx1106_fail
-    add rx1106_pos, 1
-    set_addr $I10, rxcap_1111_fail
-    ($I12, $I11) = rx1106_cur."!mark_peek"($I10)
-    rx1106_cur."!cursor_pos"($I11)
-    ($P10) = rx1106_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1106_pos, "")
-    rx1106_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1074_pos, 1
+    gt $I11, rx1074_eos, rx1074_fail
+    sub $I11, rx1074_pos, rx1074_off
+    substr $S10, rx1074_tgt, $I11, 1
+    ne $S10, "|", rx1074_fail
+    add rx1074_pos, 1
+    set_addr $I10, rxcap_1079_fail
+    ($I12, $I11) = rx1074_cur."!mark_peek"($I10)
+    rx1074_cur."!cursor_pos"($I11)
+    ($P10) = rx1074_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1074_pos, "")
+    rx1074_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1111_done
-  rxcap_1111_fail:
-    goto rx1106_fail
-  rxcap_1111_done:
+    goto rxcap_1079_done
+  rxcap_1079_fail:
+    goto rx1074_fail
+  rxcap_1079_done:
   # rx subrule "O" subtype=capture negate=
-    rx1106_cur."!cursor_pos"(rx1106_pos)
-    $P10 = rx1106_cur."O"("%symbolic_unary")
-    unless $P10, rx1106_fail
-    rx1106_cur."!mark_push"(0, -1, 0, $P10)
+    rx1074_cur."!cursor_pos"(rx1074_pos)
+    $P10 = rx1074_cur."O"("%symbolic_unary")
+    unless $P10, rx1074_fail
+    rx1074_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1106_pos = $P10."pos"()
+    rx1074_pos = $P10."pos"()
   # rx pass
-    rx1106_cur."!cursor_pass"(rx1106_pos, "prefix:sym<|>")
-    rx1106_cur."!cursor_debug"("PASS  ", "prefix:sym<|>", " at pos=", rx1106_pos)
-    .return (rx1106_cur)
-  rx1106_fail:
+    rx1074_cur."!cursor_pass"(rx1074_pos, "prefix:sym<|>")
+    rx1074_cur."!cursor_debug"("PASS  ", "prefix:sym<|>", " at pos=", rx1074_pos)
+    .return (rx1074_cur)
+  rx1074_restart:
 .annotate 'line', 447
-    (rx1106_rep, rx1106_pos, $I10, $P10) = rx1106_cur."!mark_fail"(0)
-    lt rx1106_pos, -1, rx1106_done
-    eq rx1106_pos, -1, rx1106_fail
+    rx1074_cur."!cursor_debug"("NEXT ", "prefix:sym<|>")
+  rx1074_fail:
+    (rx1074_rep, rx1074_pos, $I10, $P10) = rx1074_cur."!mark_fail"(0)
+    lt rx1074_pos, -1, rx1074_done
+    eq rx1074_pos, -1, rx1074_fail
     jump $I10
-  rx1106_done:
-    rx1106_cur."!cursor_fail"()
-    rx1106_cur."!cursor_debug"("FAIL  ", "prefix:sym<|>")
-    .return (rx1106_cur)
+  rx1074_done:
+    rx1074_cur."!cursor_fail"()
+    rx1074_cur."!cursor_debug"("FAIL  ", "prefix:sym<|>")
+    .return (rx1074_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<|>"  :subid("275_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<|>"  :subid("275_1279529226.73787") :method
 .annotate 'line', 447
-    $P1108 = self."!PREFIX__!subrule"("O", "|")
-    new $P1109, "ResizablePMCArray"
-    push $P1109, $P1108
-    .return ($P1109)
+    $P1076 = self."!PREFIX__!subrule"("O", "|")
+    new $P1077, "ResizablePMCArray"
+    push $P1077, $P1076
+    .return ($P1077)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<*>"  :subid("276_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<*>"  :subid("276_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1113_tgt
-    .local int rx1113_pos
-    .local int rx1113_off
-    .local int rx1113_eos
-    .local int rx1113_rep
-    .local pmc rx1113_cur
-    (rx1113_cur, rx1113_pos, rx1113_tgt) = self."!cursor_start"()
-    rx1113_cur."!cursor_debug"("START ", "infix:sym<*>")
-    .lex unicode:"$\x{a2}", rx1113_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1113_eos, rx1113_tgt
-    gt rx1113_pos, rx1113_eos, rx1113_done
-    set rx1113_off, 0
-    lt rx1113_pos, 2, rx1113_start
-    sub rx1113_off, rx1113_pos, 1
-    substr rx1113_tgt, rx1113_tgt, rx1113_off
-  rx1113_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1117_done
-    goto rxscan1117_scan
-  rxscan1117_loop:
-    ($P10) = rx1113_cur."from"()
-    inc $P10
-    set rx1113_pos, $P10
-    ge rx1113_pos, rx1113_eos, rxscan1117_done
-  rxscan1117_scan:
-    set_addr $I10, rxscan1117_loop
-    rx1113_cur."!mark_push"(0, rx1113_pos, $I10)
-  rxscan1117_done:
+    .local string rx1081_tgt
+    .local int rx1081_pos
+    .local int rx1081_off
+    .local int rx1081_eos
+    .local int rx1081_rep
+    .local pmc rx1081_cur
+    (rx1081_cur, rx1081_pos, rx1081_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1081_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1081_eos, rx1081_tgt
+    gt rx1081_pos, rx1081_eos, rx1081_done
+    set rx1081_off, 0
+    lt rx1081_pos, 2, rx1081_start
+    sub rx1081_off, rx1081_pos, 1
+    substr rx1081_tgt, rx1081_tgt, rx1081_off
+  rx1081_start:
+    eq $I10, 1, rx1081_restart
+    rx1081_cur."!cursor_debug"("START ", "infix:sym<*>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1085_done
+    goto rxscan1085_scan
+  rxscan1085_loop:
+    ($P10) = rx1081_cur."from"()
+    inc $P10
+    set rx1081_pos, $P10
+    ge rx1081_pos, rx1081_eos, rxscan1085_done
+  rxscan1085_scan:
+    set_addr $I10, rxscan1085_loop
+    rx1081_cur."!mark_push"(0, rx1081_pos, $I10)
+  rxscan1085_done:
 .annotate 'line', 507
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1118_fail
-    rx1113_cur."!mark_push"(0, rx1113_pos, $I10)
+    set_addr $I10, rxcap_1086_fail
+    rx1081_cur."!mark_push"(0, rx1081_pos, $I10)
   # rx literal  "*"
-    add $I11, rx1113_pos, 1
-    gt $I11, rx1113_eos, rx1113_fail
-    sub $I11, rx1113_pos, rx1113_off
-    substr $S10, rx1113_tgt, $I11, 1
-    ne $S10, "*", rx1113_fail
-    add rx1113_pos, 1
-    set_addr $I10, rxcap_1118_fail
-    ($I12, $I11) = rx1113_cur."!mark_peek"($I10)
-    rx1113_cur."!cursor_pos"($I11)
-    ($P10) = rx1113_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1113_pos, "")
-    rx1113_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1081_pos, 1
+    gt $I11, rx1081_eos, rx1081_fail
+    sub $I11, rx1081_pos, rx1081_off
+    substr $S10, rx1081_tgt, $I11, 1
+    ne $S10, "*", rx1081_fail
+    add rx1081_pos, 1
+    set_addr $I10, rxcap_1086_fail
+    ($I12, $I11) = rx1081_cur."!mark_peek"($I10)
+    rx1081_cur."!cursor_pos"($I11)
+    ($P10) = rx1081_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1081_pos, "")
+    rx1081_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1118_done
-  rxcap_1118_fail:
-    goto rx1113_fail
-  rxcap_1118_done:
+    goto rxcap_1086_done
+  rxcap_1086_fail:
+    goto rx1081_fail
+  rxcap_1086_done:
   # rx subrule "O" subtype=capture negate=
-    rx1113_cur."!cursor_pos"(rx1113_pos)
-    $P10 = rx1113_cur."O"("%multiplicative, :pirop<mul>")
-    unless $P10, rx1113_fail
-    rx1113_cur."!mark_push"(0, -1, 0, $P10)
+    rx1081_cur."!cursor_pos"(rx1081_pos)
+    $P10 = rx1081_cur."O"("%multiplicative, :pirop<mul>")
+    unless $P10, rx1081_fail
+    rx1081_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1113_pos = $P10."pos"()
+    rx1081_pos = $P10."pos"()
   # rx pass
-    rx1113_cur."!cursor_pass"(rx1113_pos, "infix:sym<*>")
-    rx1113_cur."!cursor_debug"("PASS  ", "infix:sym<*>", " at pos=", rx1113_pos)
-    .return (rx1113_cur)
-  rx1113_fail:
+    rx1081_cur."!cursor_pass"(rx1081_pos, "infix:sym<*>")
+    rx1081_cur."!cursor_debug"("PASS  ", "infix:sym<*>", " at pos=", rx1081_pos)
+    .return (rx1081_cur)
+  rx1081_restart:
 .annotate 'line', 447
-    (rx1113_rep, rx1113_pos, $I10, $P10) = rx1113_cur."!mark_fail"(0)
-    lt rx1113_pos, -1, rx1113_done
-    eq rx1113_pos, -1, rx1113_fail
+    rx1081_cur."!cursor_debug"("NEXT ", "infix:sym<*>")
+  rx1081_fail:
+    (rx1081_rep, rx1081_pos, $I10, $P10) = rx1081_cur."!mark_fail"(0)
+    lt rx1081_pos, -1, rx1081_done
+    eq rx1081_pos, -1, rx1081_fail
     jump $I10
-  rx1113_done:
-    rx1113_cur."!cursor_fail"()
-    rx1113_cur."!cursor_debug"("FAIL  ", "infix:sym<*>")
-    .return (rx1113_cur)
+  rx1081_done:
+    rx1081_cur."!cursor_fail"()
+    rx1081_cur."!cursor_debug"("FAIL  ", "infix:sym<*>")
+    .return (rx1081_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<*>"  :subid("277_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<*>"  :subid("277_1279529226.73787") :method
 .annotate 'line', 447
-    $P1115 = self."!PREFIX__!subrule"("O", "*")
-    new $P1116, "ResizablePMCArray"
-    push $P1116, $P1115
-    .return ($P1116)
+    $P1083 = self."!PREFIX__!subrule"("O", "*")
+    new $P1084, "ResizablePMCArray"
+    push $P1084, $P1083
+    .return ($P1084)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym</>"  :subid("278_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym</>"  :subid("278_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1120_tgt
-    .local int rx1120_pos
-    .local int rx1120_off
-    .local int rx1120_eos
-    .local int rx1120_rep
-    .local pmc rx1120_cur
-    (rx1120_cur, rx1120_pos, rx1120_tgt) = self."!cursor_start"()
-    rx1120_cur."!cursor_debug"("START ", "infix:sym</>")
-    .lex unicode:"$\x{a2}", rx1120_cur
+    .local string rx1088_tgt
+    .local int rx1088_pos
+    .local int rx1088_off
+    .local int rx1088_eos
+    .local int rx1088_rep
+    .local pmc rx1088_cur
+    (rx1088_cur, rx1088_pos, rx1088_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1088_cur
     .local pmc match
     .lex "$/", match
-    length rx1120_eos, rx1120_tgt
-    gt rx1120_pos, rx1120_eos, rx1120_done
-    set rx1120_off, 0
-    lt rx1120_pos, 2, rx1120_start
-    sub rx1120_off, rx1120_pos, 1
-    substr rx1120_tgt, rx1120_tgt, rx1120_off
-  rx1120_start:
+    length rx1088_eos, rx1088_tgt
+    gt rx1088_pos, rx1088_eos, rx1088_done
+    set rx1088_off, 0
+    lt rx1088_pos, 2, rx1088_start
+    sub rx1088_off, rx1088_pos, 1
+    substr rx1088_tgt, rx1088_tgt, rx1088_off
+  rx1088_start:
+    eq $I10, 1, rx1088_restart
+    rx1088_cur."!cursor_debug"("START ", "infix:sym</>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1124_done
-    goto rxscan1124_scan
-  rxscan1124_loop:
-    ($P10) = rx1120_cur."from"()
+    ne $I10, -1, rxscan1092_done
+    goto rxscan1092_scan
+  rxscan1092_loop:
+    ($P10) = rx1088_cur."from"()
     inc $P10
-    set rx1120_pos, $P10
-    ge rx1120_pos, rx1120_eos, rxscan1124_done
-  rxscan1124_scan:
-    set_addr $I10, rxscan1124_loop
-    rx1120_cur."!mark_push"(0, rx1120_pos, $I10)
-  rxscan1124_done:
+    set rx1088_pos, $P10
+    ge rx1088_pos, rx1088_eos, rxscan1092_done
+  rxscan1092_scan:
+    set_addr $I10, rxscan1092_loop
+    rx1088_cur."!mark_push"(0, rx1088_pos, $I10)
+  rxscan1092_done:
 .annotate 'line', 508
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1125_fail
-    rx1120_cur."!mark_push"(0, rx1120_pos, $I10)
+    set_addr $I10, rxcap_1093_fail
+    rx1088_cur."!mark_push"(0, rx1088_pos, $I10)
   # rx literal  "/"
-    add $I11, rx1120_pos, 1
-    gt $I11, rx1120_eos, rx1120_fail
-    sub $I11, rx1120_pos, rx1120_off
-    substr $S10, rx1120_tgt, $I11, 1
-    ne $S10, "/", rx1120_fail
-    add rx1120_pos, 1
-    set_addr $I10, rxcap_1125_fail
-    ($I12, $I11) = rx1120_cur."!mark_peek"($I10)
-    rx1120_cur."!cursor_pos"($I11)
-    ($P10) = rx1120_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1120_pos, "")
-    rx1120_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1088_pos, 1
+    gt $I11, rx1088_eos, rx1088_fail
+    sub $I11, rx1088_pos, rx1088_off
+    substr $S10, rx1088_tgt, $I11, 1
+    ne $S10, "/", rx1088_fail
+    add rx1088_pos, 1
+    set_addr $I10, rxcap_1093_fail
+    ($I12, $I11) = rx1088_cur."!mark_peek"($I10)
+    rx1088_cur."!cursor_pos"($I11)
+    ($P10) = rx1088_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1088_pos, "")
+    rx1088_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1125_done
-  rxcap_1125_fail:
-    goto rx1120_fail
-  rxcap_1125_done:
+    goto rxcap_1093_done
+  rxcap_1093_fail:
+    goto rx1088_fail
+  rxcap_1093_done:
   # rx subrule "O" subtype=capture negate=
-    rx1120_cur."!cursor_pos"(rx1120_pos)
-    $P10 = rx1120_cur."O"("%multiplicative, :pirop<div>")
-    unless $P10, rx1120_fail
-    rx1120_cur."!mark_push"(0, -1, 0, $P10)
+    rx1088_cur."!cursor_pos"(rx1088_pos)
+    $P10 = rx1088_cur."O"("%multiplicative, :pirop<div>")
+    unless $P10, rx1088_fail
+    rx1088_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1120_pos = $P10."pos"()
+    rx1088_pos = $P10."pos"()
   # rx pass
-    rx1120_cur."!cursor_pass"(rx1120_pos, "infix:sym</>")
-    rx1120_cur."!cursor_debug"("PASS  ", "infix:sym</>", " at pos=", rx1120_pos)
-    .return (rx1120_cur)
-  rx1120_fail:
+    rx1088_cur."!cursor_pass"(rx1088_pos, "infix:sym</>")
+    rx1088_cur."!cursor_debug"("PASS  ", "infix:sym</>", " at pos=", rx1088_pos)
+    .return (rx1088_cur)
+  rx1088_restart:
 .annotate 'line', 447
-    (rx1120_rep, rx1120_pos, $I10, $P10) = rx1120_cur."!mark_fail"(0)
-    lt rx1120_pos, -1, rx1120_done
-    eq rx1120_pos, -1, rx1120_fail
+    rx1088_cur."!cursor_debug"("NEXT ", "infix:sym</>")
+  rx1088_fail:
+    (rx1088_rep, rx1088_pos, $I10, $P10) = rx1088_cur."!mark_fail"(0)
+    lt rx1088_pos, -1, rx1088_done
+    eq rx1088_pos, -1, rx1088_fail
     jump $I10
-  rx1120_done:
-    rx1120_cur."!cursor_fail"()
-    rx1120_cur."!cursor_debug"("FAIL  ", "infix:sym</>")
-    .return (rx1120_cur)
+  rx1088_done:
+    rx1088_cur."!cursor_fail"()
+    rx1088_cur."!cursor_debug"("FAIL  ", "infix:sym</>")
+    .return (rx1088_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym</>"  :subid("279_1278500537.15927") :method
+.sub "!PREFIX__infix:sym</>"  :subid("279_1279529226.73787") :method
 .annotate 'line', 447
-    $P1122 = self."!PREFIX__!subrule"("O", "/")
-    new $P1123, "ResizablePMCArray"
-    push $P1123, $P1122
-    .return ($P1123)
+    $P1090 = self."!PREFIX__!subrule"("O", "/")
+    new $P1091, "ResizablePMCArray"
+    push $P1091, $P1090
+    .return ($P1091)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<%>"  :subid("280_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<%>"  :subid("280_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1127_tgt
-    .local int rx1127_pos
-    .local int rx1127_off
-    .local int rx1127_eos
-    .local int rx1127_rep
-    .local pmc rx1127_cur
-    (rx1127_cur, rx1127_pos, rx1127_tgt) = self."!cursor_start"()
-    rx1127_cur."!cursor_debug"("START ", "infix:sym<%>")
-    .lex unicode:"$\x{a2}", rx1127_cur
+    .local string rx1095_tgt
+    .local int rx1095_pos
+    .local int rx1095_off
+    .local int rx1095_eos
+    .local int rx1095_rep
+    .local pmc rx1095_cur
+    (rx1095_cur, rx1095_pos, rx1095_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1095_cur
     .local pmc match
     .lex "$/", match
-    length rx1127_eos, rx1127_tgt
-    gt rx1127_pos, rx1127_eos, rx1127_done
-    set rx1127_off, 0
-    lt rx1127_pos, 2, rx1127_start
-    sub rx1127_off, rx1127_pos, 1
-    substr rx1127_tgt, rx1127_tgt, rx1127_off
-  rx1127_start:
+    length rx1095_eos, rx1095_tgt
+    gt rx1095_pos, rx1095_eos, rx1095_done
+    set rx1095_off, 0
+    lt rx1095_pos, 2, rx1095_start
+    sub rx1095_off, rx1095_pos, 1
+    substr rx1095_tgt, rx1095_tgt, rx1095_off
+  rx1095_start:
+    eq $I10, 1, rx1095_restart
+    rx1095_cur."!cursor_debug"("START ", "infix:sym<%>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1131_done
-    goto rxscan1131_scan
-  rxscan1131_loop:
-    ($P10) = rx1127_cur."from"()
+    ne $I10, -1, rxscan1099_done
+    goto rxscan1099_scan
+  rxscan1099_loop:
+    ($P10) = rx1095_cur."from"()
     inc $P10
-    set rx1127_pos, $P10
-    ge rx1127_pos, rx1127_eos, rxscan1131_done
-  rxscan1131_scan:
-    set_addr $I10, rxscan1131_loop
-    rx1127_cur."!mark_push"(0, rx1127_pos, $I10)
-  rxscan1131_done:
+    set rx1095_pos, $P10
+    ge rx1095_pos, rx1095_eos, rxscan1099_done
+  rxscan1099_scan:
+    set_addr $I10, rxscan1099_loop
+    rx1095_cur."!mark_push"(0, rx1095_pos, $I10)
+  rxscan1099_done:
 .annotate 'line', 509
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1132_fail
-    rx1127_cur."!mark_push"(0, rx1127_pos, $I10)
+    set_addr $I10, rxcap_1100_fail
+    rx1095_cur."!mark_push"(0, rx1095_pos, $I10)
   # rx literal  "%"
-    add $I11, rx1127_pos, 1
-    gt $I11, rx1127_eos, rx1127_fail
-    sub $I11, rx1127_pos, rx1127_off
-    substr $S10, rx1127_tgt, $I11, 1
-    ne $S10, "%", rx1127_fail
-    add rx1127_pos, 1
-    set_addr $I10, rxcap_1132_fail
-    ($I12, $I11) = rx1127_cur."!mark_peek"($I10)
-    rx1127_cur."!cursor_pos"($I11)
-    ($P10) = rx1127_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1127_pos, "")
-    rx1127_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1095_pos, 1
+    gt $I11, rx1095_eos, rx1095_fail
+    sub $I11, rx1095_pos, rx1095_off
+    substr $S10, rx1095_tgt, $I11, 1
+    ne $S10, "%", rx1095_fail
+    add rx1095_pos, 1
+    set_addr $I10, rxcap_1100_fail
+    ($I12, $I11) = rx1095_cur."!mark_peek"($I10)
+    rx1095_cur."!cursor_pos"($I11)
+    ($P10) = rx1095_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1095_pos, "")
+    rx1095_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1132_done
-  rxcap_1132_fail:
-    goto rx1127_fail
-  rxcap_1132_done:
+    goto rxcap_1100_done
+  rxcap_1100_fail:
+    goto rx1095_fail
+  rxcap_1100_done:
   # rx subrule "O" subtype=capture negate=
-    rx1127_cur."!cursor_pos"(rx1127_pos)
-    $P10 = rx1127_cur."O"("%multiplicative, :pirop<mod>")
-    unless $P10, rx1127_fail
-    rx1127_cur."!mark_push"(0, -1, 0, $P10)
+    rx1095_cur."!cursor_pos"(rx1095_pos)
+    $P10 = rx1095_cur."O"("%multiplicative, :pirop<mod>")
+    unless $P10, rx1095_fail
+    rx1095_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1127_pos = $P10."pos"()
+    rx1095_pos = $P10."pos"()
   # rx pass
-    rx1127_cur."!cursor_pass"(rx1127_pos, "infix:sym<%>")
-    rx1127_cur."!cursor_debug"("PASS  ", "infix:sym<%>", " at pos=", rx1127_pos)
-    .return (rx1127_cur)
-  rx1127_fail:
+    rx1095_cur."!cursor_pass"(rx1095_pos, "infix:sym<%>")
+    rx1095_cur."!cursor_debug"("PASS  ", "infix:sym<%>", " at pos=", rx1095_pos)
+    .return (rx1095_cur)
+  rx1095_restart:
 .annotate 'line', 447
-    (rx1127_rep, rx1127_pos, $I10, $P10) = rx1127_cur."!mark_fail"(0)
-    lt rx1127_pos, -1, rx1127_done
-    eq rx1127_pos, -1, rx1127_fail
+    rx1095_cur."!cursor_debug"("NEXT ", "infix:sym<%>")
+  rx1095_fail:
+    (rx1095_rep, rx1095_pos, $I10, $P10) = rx1095_cur."!mark_fail"(0)
+    lt rx1095_pos, -1, rx1095_done
+    eq rx1095_pos, -1, rx1095_fail
     jump $I10
-  rx1127_done:
-    rx1127_cur."!cursor_fail"()
-    rx1127_cur."!cursor_debug"("FAIL  ", "infix:sym<%>")
-    .return (rx1127_cur)
+  rx1095_done:
+    rx1095_cur."!cursor_fail"()
+    rx1095_cur."!cursor_debug"("FAIL  ", "infix:sym<%>")
+    .return (rx1095_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<%>"  :subid("281_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<%>"  :subid("281_1279529226.73787") :method
 .annotate 'line', 447
-    $P1129 = self."!PREFIX__!subrule"("O", "%")
-    new $P1130, "ResizablePMCArray"
-    push $P1130, $P1129
-    .return ($P1130)
+    $P1097 = self."!PREFIX__!subrule"("O", "%")
+    new $P1098, "ResizablePMCArray"
+    push $P1098, $P1097
+    .return ($P1098)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<+&>"  :subid("282_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<+&>"  :subid("282_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1134_tgt
-    .local int rx1134_pos
-    .local int rx1134_off
-    .local int rx1134_eos
-    .local int rx1134_rep
-    .local pmc rx1134_cur
-    (rx1134_cur, rx1134_pos, rx1134_tgt) = self."!cursor_start"()
-    rx1134_cur."!cursor_debug"("START ", "infix:sym<+&>")
-    .lex unicode:"$\x{a2}", rx1134_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1134_eos, rx1134_tgt
-    gt rx1134_pos, rx1134_eos, rx1134_done
-    set rx1134_off, 0
-    lt rx1134_pos, 2, rx1134_start
-    sub rx1134_off, rx1134_pos, 1
-    substr rx1134_tgt, rx1134_tgt, rx1134_off
-  rx1134_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1138_done
-    goto rxscan1138_scan
-  rxscan1138_loop:
-    ($P10) = rx1134_cur."from"()
-    inc $P10
-    set rx1134_pos, $P10
-    ge rx1134_pos, rx1134_eos, rxscan1138_done
-  rxscan1138_scan:
-    set_addr $I10, rxscan1138_loop
-    rx1134_cur."!mark_push"(0, rx1134_pos, $I10)
-  rxscan1138_done:
+    .local string rx1102_tgt
+    .local int rx1102_pos
+    .local int rx1102_off
+    .local int rx1102_eos
+    .local int rx1102_rep
+    .local pmc rx1102_cur
+    (rx1102_cur, rx1102_pos, rx1102_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1102_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1102_eos, rx1102_tgt
+    gt rx1102_pos, rx1102_eos, rx1102_done
+    set rx1102_off, 0
+    lt rx1102_pos, 2, rx1102_start
+    sub rx1102_off, rx1102_pos, 1
+    substr rx1102_tgt, rx1102_tgt, rx1102_off
+  rx1102_start:
+    eq $I10, 1, rx1102_restart
+    rx1102_cur."!cursor_debug"("START ", "infix:sym<+&>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1106_done
+    goto rxscan1106_scan
+  rxscan1106_loop:
+    ($P10) = rx1102_cur."from"()
+    inc $P10
+    set rx1102_pos, $P10
+    ge rx1102_pos, rx1102_eos, rxscan1106_done
+  rxscan1106_scan:
+    set_addr $I10, rxscan1106_loop
+    rx1102_cur."!mark_push"(0, rx1102_pos, $I10)
+  rxscan1106_done:
 .annotate 'line', 510
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1139_fail
-    rx1134_cur."!mark_push"(0, rx1134_pos, $I10)
+    set_addr $I10, rxcap_1107_fail
+    rx1102_cur."!mark_push"(0, rx1102_pos, $I10)
   # rx literal  "+&"
-    add $I11, rx1134_pos, 2
-    gt $I11, rx1134_eos, rx1134_fail
-    sub $I11, rx1134_pos, rx1134_off
-    substr $S10, rx1134_tgt, $I11, 2
-    ne $S10, "+&", rx1134_fail
-    add rx1134_pos, 2
-    set_addr $I10, rxcap_1139_fail
-    ($I12, $I11) = rx1134_cur."!mark_peek"($I10)
-    rx1134_cur."!cursor_pos"($I11)
-    ($P10) = rx1134_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1134_pos, "")
-    rx1134_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1102_pos, 2
+    gt $I11, rx1102_eos, rx1102_fail
+    sub $I11, rx1102_pos, rx1102_off
+    substr $S10, rx1102_tgt, $I11, 2
+    ne $S10, "+&", rx1102_fail
+    add rx1102_pos, 2
+    set_addr $I10, rxcap_1107_fail
+    ($I12, $I11) = rx1102_cur."!mark_peek"($I10)
+    rx1102_cur."!cursor_pos"($I11)
+    ($P10) = rx1102_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1102_pos, "")
+    rx1102_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1139_done
-  rxcap_1139_fail:
-    goto rx1134_fail
-  rxcap_1139_done:
+    goto rxcap_1107_done
+  rxcap_1107_fail:
+    goto rx1102_fail
+  rxcap_1107_done:
   # rx subrule "O" subtype=capture negate=
-    rx1134_cur."!cursor_pos"(rx1134_pos)
-    $P10 = rx1134_cur."O"("%multiplicative, :pirop<band III>")
-    unless $P10, rx1134_fail
-    rx1134_cur."!mark_push"(0, -1, 0, $P10)
+    rx1102_cur."!cursor_pos"(rx1102_pos)
+    $P10 = rx1102_cur."O"("%multiplicative, :pirop<band III>")
+    unless $P10, rx1102_fail
+    rx1102_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1134_pos = $P10."pos"()
+    rx1102_pos = $P10."pos"()
   # rx pass
-    rx1134_cur."!cursor_pass"(rx1134_pos, "infix:sym<+&>")
-    rx1134_cur."!cursor_debug"("PASS  ", "infix:sym<+&>", " at pos=", rx1134_pos)
-    .return (rx1134_cur)
-  rx1134_fail:
+    rx1102_cur."!cursor_pass"(rx1102_pos, "infix:sym<+&>")
+    rx1102_cur."!cursor_debug"("PASS  ", "infix:sym<+&>", " at pos=", rx1102_pos)
+    .return (rx1102_cur)
+  rx1102_restart:
 .annotate 'line', 447
-    (rx1134_rep, rx1134_pos, $I10, $P10) = rx1134_cur."!mark_fail"(0)
-    lt rx1134_pos, -1, rx1134_done
-    eq rx1134_pos, -1, rx1134_fail
+    rx1102_cur."!cursor_debug"("NEXT ", "infix:sym<+&>")
+  rx1102_fail:
+    (rx1102_rep, rx1102_pos, $I10, $P10) = rx1102_cur."!mark_fail"(0)
+    lt rx1102_pos, -1, rx1102_done
+    eq rx1102_pos, -1, rx1102_fail
     jump $I10
-  rx1134_done:
-    rx1134_cur."!cursor_fail"()
-    rx1134_cur."!cursor_debug"("FAIL  ", "infix:sym<+&>")
-    .return (rx1134_cur)
+  rx1102_done:
+    rx1102_cur."!cursor_fail"()
+    rx1102_cur."!cursor_debug"("FAIL  ", "infix:sym<+&>")
+    .return (rx1102_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<+&>"  :subid("283_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<+&>"  :subid("283_1279529226.73787") :method
 .annotate 'line', 447
-    $P1136 = self."!PREFIX__!subrule"("O", "+&")
-    new $P1137, "ResizablePMCArray"
-    push $P1137, $P1136
-    .return ($P1137)
+    $P1104 = self."!PREFIX__!subrule"("O", "+&")
+    new $P1105, "ResizablePMCArray"
+    push $P1105, $P1104
+    .return ($P1105)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<+>"  :subid("284_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<+>"  :subid("284_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1141_tgt
-    .local int rx1141_pos
-    .local int rx1141_off
-    .local int rx1141_eos
-    .local int rx1141_rep
-    .local pmc rx1141_cur
-    (rx1141_cur, rx1141_pos, rx1141_tgt) = self."!cursor_start"()
-    rx1141_cur."!cursor_debug"("START ", "infix:sym<+>")
-    .lex unicode:"$\x{a2}", rx1141_cur
+    .local string rx1109_tgt
+    .local int rx1109_pos
+    .local int rx1109_off
+    .local int rx1109_eos
+    .local int rx1109_rep
+    .local pmc rx1109_cur
+    (rx1109_cur, rx1109_pos, rx1109_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1109_cur
     .local pmc match
     .lex "$/", match
-    length rx1141_eos, rx1141_tgt
-    gt rx1141_pos, rx1141_eos, rx1141_done
-    set rx1141_off, 0
-    lt rx1141_pos, 2, rx1141_start
-    sub rx1141_off, rx1141_pos, 1
-    substr rx1141_tgt, rx1141_tgt, rx1141_off
-  rx1141_start:
+    length rx1109_eos, rx1109_tgt
+    gt rx1109_pos, rx1109_eos, rx1109_done
+    set rx1109_off, 0
+    lt rx1109_pos, 2, rx1109_start
+    sub rx1109_off, rx1109_pos, 1
+    substr rx1109_tgt, rx1109_tgt, rx1109_off
+  rx1109_start:
+    eq $I10, 1, rx1109_restart
+    rx1109_cur."!cursor_debug"("START ", "infix:sym<+>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1145_done
-    goto rxscan1145_scan
-  rxscan1145_loop:
-    ($P10) = rx1141_cur."from"()
+    ne $I10, -1, rxscan1113_done
+    goto rxscan1113_scan
+  rxscan1113_loop:
+    ($P10) = rx1109_cur."from"()
     inc $P10
-    set rx1141_pos, $P10
-    ge rx1141_pos, rx1141_eos, rxscan1145_done
-  rxscan1145_scan:
-    set_addr $I10, rxscan1145_loop
-    rx1141_cur."!mark_push"(0, rx1141_pos, $I10)
-  rxscan1145_done:
+    set rx1109_pos, $P10
+    ge rx1109_pos, rx1109_eos, rxscan1113_done
+  rxscan1113_scan:
+    set_addr $I10, rxscan1113_loop
+    rx1109_cur."!mark_push"(0, rx1109_pos, $I10)
+  rxscan1113_done:
 .annotate 'line', 512
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1146_fail
-    rx1141_cur."!mark_push"(0, rx1141_pos, $I10)
+    set_addr $I10, rxcap_1114_fail
+    rx1109_cur."!mark_push"(0, rx1109_pos, $I10)
   # rx literal  "+"
-    add $I11, rx1141_pos, 1
-    gt $I11, rx1141_eos, rx1141_fail
-    sub $I11, rx1141_pos, rx1141_off
-    substr $S10, rx1141_tgt, $I11, 1
-    ne $S10, "+", rx1141_fail
-    add rx1141_pos, 1
-    set_addr $I10, rxcap_1146_fail
-    ($I12, $I11) = rx1141_cur."!mark_peek"($I10)
-    rx1141_cur."!cursor_pos"($I11)
-    ($P10) = rx1141_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1141_pos, "")
-    rx1141_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1109_pos, 1
+    gt $I11, rx1109_eos, rx1109_fail
+    sub $I11, rx1109_pos, rx1109_off
+    substr $S10, rx1109_tgt, $I11, 1
+    ne $S10, "+", rx1109_fail
+    add rx1109_pos, 1
+    set_addr $I10, rxcap_1114_fail
+    ($I12, $I11) = rx1109_cur."!mark_peek"($I10)
+    rx1109_cur."!cursor_pos"($I11)
+    ($P10) = rx1109_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1109_pos, "")
+    rx1109_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1146_done
-  rxcap_1146_fail:
-    goto rx1141_fail
-  rxcap_1146_done:
+    goto rxcap_1114_done
+  rxcap_1114_fail:
+    goto rx1109_fail
+  rxcap_1114_done:
   # rx subrule "O" subtype=capture negate=
-    rx1141_cur."!cursor_pos"(rx1141_pos)
-    $P10 = rx1141_cur."O"("%additive, :pirop<add>")
-    unless $P10, rx1141_fail
-    rx1141_cur."!mark_push"(0, -1, 0, $P10)
+    rx1109_cur."!cursor_pos"(rx1109_pos)
+    $P10 = rx1109_cur."O"("%additive, :pirop<add>")
+    unless $P10, rx1109_fail
+    rx1109_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1141_pos = $P10."pos"()
+    rx1109_pos = $P10."pos"()
   # rx pass
-    rx1141_cur."!cursor_pass"(rx1141_pos, "infix:sym<+>")
-    rx1141_cur."!cursor_debug"("PASS  ", "infix:sym<+>", " at pos=", rx1141_pos)
-    .return (rx1141_cur)
-  rx1141_fail:
+    rx1109_cur."!cursor_pass"(rx1109_pos, "infix:sym<+>")
+    rx1109_cur."!cursor_debug"("PASS  ", "infix:sym<+>", " at pos=", rx1109_pos)
+    .return (rx1109_cur)
+  rx1109_restart:
 .annotate 'line', 447
-    (rx1141_rep, rx1141_pos, $I10, $P10) = rx1141_cur."!mark_fail"(0)
-    lt rx1141_pos, -1, rx1141_done
-    eq rx1141_pos, -1, rx1141_fail
+    rx1109_cur."!cursor_debug"("NEXT ", "infix:sym<+>")
+  rx1109_fail:
+    (rx1109_rep, rx1109_pos, $I10, $P10) = rx1109_cur."!mark_fail"(0)
+    lt rx1109_pos, -1, rx1109_done
+    eq rx1109_pos, -1, rx1109_fail
     jump $I10
-  rx1141_done:
-    rx1141_cur."!cursor_fail"()
-    rx1141_cur."!cursor_debug"("FAIL  ", "infix:sym<+>")
-    .return (rx1141_cur)
+  rx1109_done:
+    rx1109_cur."!cursor_fail"()
+    rx1109_cur."!cursor_debug"("FAIL  ", "infix:sym<+>")
+    .return (rx1109_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<+>"  :subid("285_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<+>"  :subid("285_1279529226.73787") :method
 .annotate 'line', 447
-    $P1143 = self."!PREFIX__!subrule"("O", "+")
-    new $P1144, "ResizablePMCArray"
-    push $P1144, $P1143
-    .return ($P1144)
+    $P1111 = self."!PREFIX__!subrule"("O", "+")
+    new $P1112, "ResizablePMCArray"
+    push $P1112, $P1111
+    .return ($P1112)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<->"  :subid("286_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<->"  :subid("286_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1148_tgt
-    .local int rx1148_pos
-    .local int rx1148_off
-    .local int rx1148_eos
-    .local int rx1148_rep
-    .local pmc rx1148_cur
-    (rx1148_cur, rx1148_pos, rx1148_tgt) = self."!cursor_start"()
-    rx1148_cur."!cursor_debug"("START ", "infix:sym<->")
-    .lex unicode:"$\x{a2}", rx1148_cur
+    .local string rx1116_tgt
+    .local int rx1116_pos
+    .local int rx1116_off
+    .local int rx1116_eos
+    .local int rx1116_rep
+    .local pmc rx1116_cur
+    (rx1116_cur, rx1116_pos, rx1116_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1116_cur
     .local pmc match
     .lex "$/", match
-    length rx1148_eos, rx1148_tgt
-    gt rx1148_pos, rx1148_eos, rx1148_done
-    set rx1148_off, 0
-    lt rx1148_pos, 2, rx1148_start
-    sub rx1148_off, rx1148_pos, 1
-    substr rx1148_tgt, rx1148_tgt, rx1148_off
-  rx1148_start:
+    length rx1116_eos, rx1116_tgt
+    gt rx1116_pos, rx1116_eos, rx1116_done
+    set rx1116_off, 0
+    lt rx1116_pos, 2, rx1116_start
+    sub rx1116_off, rx1116_pos, 1
+    substr rx1116_tgt, rx1116_tgt, rx1116_off
+  rx1116_start:
+    eq $I10, 1, rx1116_restart
+    rx1116_cur."!cursor_debug"("START ", "infix:sym<->")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1152_done
-    goto rxscan1152_scan
-  rxscan1152_loop:
-    ($P10) = rx1148_cur."from"()
+    ne $I10, -1, rxscan1120_done
+    goto rxscan1120_scan
+  rxscan1120_loop:
+    ($P10) = rx1116_cur."from"()
     inc $P10
-    set rx1148_pos, $P10
-    ge rx1148_pos, rx1148_eos, rxscan1152_done
-  rxscan1152_scan:
-    set_addr $I10, rxscan1152_loop
-    rx1148_cur."!mark_push"(0, rx1148_pos, $I10)
-  rxscan1152_done:
+    set rx1116_pos, $P10
+    ge rx1116_pos, rx1116_eos, rxscan1120_done
+  rxscan1120_scan:
+    set_addr $I10, rxscan1120_loop
+    rx1116_cur."!mark_push"(0, rx1116_pos, $I10)
+  rxscan1120_done:
 .annotate 'line', 513
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1153_fail
-    rx1148_cur."!mark_push"(0, rx1148_pos, $I10)
+    set_addr $I10, rxcap_1121_fail
+    rx1116_cur."!mark_push"(0, rx1116_pos, $I10)
   # rx literal  "-"
-    add $I11, rx1148_pos, 1
-    gt $I11, rx1148_eos, rx1148_fail
-    sub $I11, rx1148_pos, rx1148_off
-    substr $S10, rx1148_tgt, $I11, 1
-    ne $S10, "-", rx1148_fail
-    add rx1148_pos, 1
-    set_addr $I10, rxcap_1153_fail
-    ($I12, $I11) = rx1148_cur."!mark_peek"($I10)
-    rx1148_cur."!cursor_pos"($I11)
-    ($P10) = rx1148_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1148_pos, "")
-    rx1148_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1116_pos, 1
+    gt $I11, rx1116_eos, rx1116_fail
+    sub $I11, rx1116_pos, rx1116_off
+    substr $S10, rx1116_tgt, $I11, 1
+    ne $S10, "-", rx1116_fail
+    add rx1116_pos, 1
+    set_addr $I10, rxcap_1121_fail
+    ($I12, $I11) = rx1116_cur."!mark_peek"($I10)
+    rx1116_cur."!cursor_pos"($I11)
+    ($P10) = rx1116_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1116_pos, "")
+    rx1116_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1153_done
-  rxcap_1153_fail:
-    goto rx1148_fail
-  rxcap_1153_done:
+    goto rxcap_1121_done
+  rxcap_1121_fail:
+    goto rx1116_fail
+  rxcap_1121_done:
   # rx subrule "O" subtype=capture negate=
-    rx1148_cur."!cursor_pos"(rx1148_pos)
-    $P10 = rx1148_cur."O"("%additive, :pirop<sub>")
-    unless $P10, rx1148_fail
-    rx1148_cur."!mark_push"(0, -1, 0, $P10)
+    rx1116_cur."!cursor_pos"(rx1116_pos)
+    $P10 = rx1116_cur."O"("%additive, :pirop<sub>")
+    unless $P10, rx1116_fail
+    rx1116_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1148_pos = $P10."pos"()
+    rx1116_pos = $P10."pos"()
   # rx pass
-    rx1148_cur."!cursor_pass"(rx1148_pos, "infix:sym<->")
-    rx1148_cur."!cursor_debug"("PASS  ", "infix:sym<->", " at pos=", rx1148_pos)
-    .return (rx1148_cur)
-  rx1148_fail:
+    rx1116_cur."!cursor_pass"(rx1116_pos, "infix:sym<->")
+    rx1116_cur."!cursor_debug"("PASS  ", "infix:sym<->", " at pos=", rx1116_pos)
+    .return (rx1116_cur)
+  rx1116_restart:
 .annotate 'line', 447
-    (rx1148_rep, rx1148_pos, $I10, $P10) = rx1148_cur."!mark_fail"(0)
-    lt rx1148_pos, -1, rx1148_done
-    eq rx1148_pos, -1, rx1148_fail
+    rx1116_cur."!cursor_debug"("NEXT ", "infix:sym<->")
+  rx1116_fail:
+    (rx1116_rep, rx1116_pos, $I10, $P10) = rx1116_cur."!mark_fail"(0)
+    lt rx1116_pos, -1, rx1116_done
+    eq rx1116_pos, -1, rx1116_fail
     jump $I10
-  rx1148_done:
-    rx1148_cur."!cursor_fail"()
-    rx1148_cur."!cursor_debug"("FAIL  ", "infix:sym<->")
-    .return (rx1148_cur)
+  rx1116_done:
+    rx1116_cur."!cursor_fail"()
+    rx1116_cur."!cursor_debug"("FAIL  ", "infix:sym<->")
+    .return (rx1116_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<->"  :subid("287_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<->"  :subid("287_1279529226.73787") :method
 .annotate 'line', 447
-    $P1150 = self."!PREFIX__!subrule"("O", "-")
-    new $P1151, "ResizablePMCArray"
-    push $P1151, $P1150
-    .return ($P1151)
+    $P1118 = self."!PREFIX__!subrule"("O", "-")
+    new $P1119, "ResizablePMCArray"
+    push $P1119, $P1118
+    .return ($P1119)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<+|>"  :subid("288_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<+|>"  :subid("288_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1155_tgt
-    .local int rx1155_pos
-    .local int rx1155_off
-    .local int rx1155_eos
-    .local int rx1155_rep
-    .local pmc rx1155_cur
-    (rx1155_cur, rx1155_pos, rx1155_tgt) = self."!cursor_start"()
-    rx1155_cur."!cursor_debug"("START ", "infix:sym<+|>")
-    .lex unicode:"$\x{a2}", rx1155_cur
+    .local string rx1123_tgt
+    .local int rx1123_pos
+    .local int rx1123_off
+    .local int rx1123_eos
+    .local int rx1123_rep
+    .local pmc rx1123_cur
+    (rx1123_cur, rx1123_pos, rx1123_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1123_cur
     .local pmc match
     .lex "$/", match
-    length rx1155_eos, rx1155_tgt
-    gt rx1155_pos, rx1155_eos, rx1155_done
-    set rx1155_off, 0
-    lt rx1155_pos, 2, rx1155_start
-    sub rx1155_off, rx1155_pos, 1
-    substr rx1155_tgt, rx1155_tgt, rx1155_off
-  rx1155_start:
+    length rx1123_eos, rx1123_tgt
+    gt rx1123_pos, rx1123_eos, rx1123_done
+    set rx1123_off, 0
+    lt rx1123_pos, 2, rx1123_start
+    sub rx1123_off, rx1123_pos, 1
+    substr rx1123_tgt, rx1123_tgt, rx1123_off
+  rx1123_start:
+    eq $I10, 1, rx1123_restart
+    rx1123_cur."!cursor_debug"("START ", "infix:sym<+|>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1159_done
-    goto rxscan1159_scan
-  rxscan1159_loop:
-    ($P10) = rx1155_cur."from"()
+    ne $I10, -1, rxscan1127_done
+    goto rxscan1127_scan
+  rxscan1127_loop:
+    ($P10) = rx1123_cur."from"()
     inc $P10
-    set rx1155_pos, $P10
-    ge rx1155_pos, rx1155_eos, rxscan1159_done
-  rxscan1159_scan:
-    set_addr $I10, rxscan1159_loop
-    rx1155_cur."!mark_push"(0, rx1155_pos, $I10)
-  rxscan1159_done:
+    set rx1123_pos, $P10
+    ge rx1123_pos, rx1123_eos, rxscan1127_done
+  rxscan1127_scan:
+    set_addr $I10, rxscan1127_loop
+    rx1123_cur."!mark_push"(0, rx1123_pos, $I10)
+  rxscan1127_done:
 .annotate 'line', 514
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1160_fail
-    rx1155_cur."!mark_push"(0, rx1155_pos, $I10)
+    set_addr $I10, rxcap_1128_fail
+    rx1123_cur."!mark_push"(0, rx1123_pos, $I10)
   # rx literal  "+|"
-    add $I11, rx1155_pos, 2
-    gt $I11, rx1155_eos, rx1155_fail
-    sub $I11, rx1155_pos, rx1155_off
-    substr $S10, rx1155_tgt, $I11, 2
-    ne $S10, "+|", rx1155_fail
-    add rx1155_pos, 2
-    set_addr $I10, rxcap_1160_fail
-    ($I12, $I11) = rx1155_cur."!mark_peek"($I10)
-    rx1155_cur."!cursor_pos"($I11)
-    ($P10) = rx1155_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1155_pos, "")
-    rx1155_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1123_pos, 2
+    gt $I11, rx1123_eos, rx1123_fail
+    sub $I11, rx1123_pos, rx1123_off
+    substr $S10, rx1123_tgt, $I11, 2
+    ne $S10, "+|", rx1123_fail
+    add rx1123_pos, 2
+    set_addr $I10, rxcap_1128_fail
+    ($I12, $I11) = rx1123_cur."!mark_peek"($I10)
+    rx1123_cur."!cursor_pos"($I11)
+    ($P10) = rx1123_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1123_pos, "")
+    rx1123_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1160_done
-  rxcap_1160_fail:
-    goto rx1155_fail
-  rxcap_1160_done:
+    goto rxcap_1128_done
+  rxcap_1128_fail:
+    goto rx1123_fail
+  rxcap_1128_done:
   # rx subrule "O" subtype=capture negate=
-    rx1155_cur."!cursor_pos"(rx1155_pos)
-    $P10 = rx1155_cur."O"("%additive, :pirop<bor III>")
-    unless $P10, rx1155_fail
-    rx1155_cur."!mark_push"(0, -1, 0, $P10)
+    rx1123_cur."!cursor_pos"(rx1123_pos)
+    $P10 = rx1123_cur."O"("%additive, :pirop<bor III>")
+    unless $P10, rx1123_fail
+    rx1123_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1155_pos = $P10."pos"()
+    rx1123_pos = $P10."pos"()
   # rx pass
-    rx1155_cur."!cursor_pass"(rx1155_pos, "infix:sym<+|>")
-    rx1155_cur."!cursor_debug"("PASS  ", "infix:sym<+|>", " at pos=", rx1155_pos)
-    .return (rx1155_cur)
-  rx1155_fail:
+    rx1123_cur."!cursor_pass"(rx1123_pos, "infix:sym<+|>")
+    rx1123_cur."!cursor_debug"("PASS  ", "infix:sym<+|>", " at pos=", rx1123_pos)
+    .return (rx1123_cur)
+  rx1123_restart:
 .annotate 'line', 447
-    (rx1155_rep, rx1155_pos, $I10, $P10) = rx1155_cur."!mark_fail"(0)
-    lt rx1155_pos, -1, rx1155_done
-    eq rx1155_pos, -1, rx1155_fail
+    rx1123_cur."!cursor_debug"("NEXT ", "infix:sym<+|>")
+  rx1123_fail:
+    (rx1123_rep, rx1123_pos, $I10, $P10) = rx1123_cur."!mark_fail"(0)
+    lt rx1123_pos, -1, rx1123_done
+    eq rx1123_pos, -1, rx1123_fail
     jump $I10
-  rx1155_done:
-    rx1155_cur."!cursor_fail"()
-    rx1155_cur."!cursor_debug"("FAIL  ", "infix:sym<+|>")
-    .return (rx1155_cur)
+  rx1123_done:
+    rx1123_cur."!cursor_fail"()
+    rx1123_cur."!cursor_debug"("FAIL  ", "infix:sym<+|>")
+    .return (rx1123_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<+|>"  :subid("289_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<+|>"  :subid("289_1279529226.73787") :method
 .annotate 'line', 447
-    $P1157 = self."!PREFIX__!subrule"("O", "+|")
-    new $P1158, "ResizablePMCArray"
-    push $P1158, $P1157
-    .return ($P1158)
+    $P1125 = self."!PREFIX__!subrule"("O", "+|")
+    new $P1126, "ResizablePMCArray"
+    push $P1126, $P1125
+    .return ($P1126)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<+^>"  :subid("290_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<+^>"  :subid("290_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1162_tgt
-    .local int rx1162_pos
-    .local int rx1162_off
-    .local int rx1162_eos
-    .local int rx1162_rep
-    .local pmc rx1162_cur
-    (rx1162_cur, rx1162_pos, rx1162_tgt) = self."!cursor_start"()
-    rx1162_cur."!cursor_debug"("START ", "infix:sym<+^>")
-    .lex unicode:"$\x{a2}", rx1162_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1162_eos, rx1162_tgt
-    gt rx1162_pos, rx1162_eos, rx1162_done
-    set rx1162_off, 0
-    lt rx1162_pos, 2, rx1162_start
-    sub rx1162_off, rx1162_pos, 1
-    substr rx1162_tgt, rx1162_tgt, rx1162_off
-  rx1162_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1166_done
-    goto rxscan1166_scan
-  rxscan1166_loop:
-    ($P10) = rx1162_cur."from"()
-    inc $P10
-    set rx1162_pos, $P10
-    ge rx1162_pos, rx1162_eos, rxscan1166_done
-  rxscan1166_scan:
-    set_addr $I10, rxscan1166_loop
-    rx1162_cur."!mark_push"(0, rx1162_pos, $I10)
-  rxscan1166_done:
+    .local string rx1130_tgt
+    .local int rx1130_pos
+    .local int rx1130_off
+    .local int rx1130_eos
+    .local int rx1130_rep
+    .local pmc rx1130_cur
+    (rx1130_cur, rx1130_pos, rx1130_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1130_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1130_eos, rx1130_tgt
+    gt rx1130_pos, rx1130_eos, rx1130_done
+    set rx1130_off, 0
+    lt rx1130_pos, 2, rx1130_start
+    sub rx1130_off, rx1130_pos, 1
+    substr rx1130_tgt, rx1130_tgt, rx1130_off
+  rx1130_start:
+    eq $I10, 1, rx1130_restart
+    rx1130_cur."!cursor_debug"("START ", "infix:sym<+^>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1134_done
+    goto rxscan1134_scan
+  rxscan1134_loop:
+    ($P10) = rx1130_cur."from"()
+    inc $P10
+    set rx1130_pos, $P10
+    ge rx1130_pos, rx1130_eos, rxscan1134_done
+  rxscan1134_scan:
+    set_addr $I10, rxscan1134_loop
+    rx1130_cur."!mark_push"(0, rx1130_pos, $I10)
+  rxscan1134_done:
 .annotate 'line', 515
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1167_fail
-    rx1162_cur."!mark_push"(0, rx1162_pos, $I10)
+    set_addr $I10, rxcap_1135_fail
+    rx1130_cur."!mark_push"(0, rx1130_pos, $I10)
   # rx literal  "+^"
-    add $I11, rx1162_pos, 2
-    gt $I11, rx1162_eos, rx1162_fail
-    sub $I11, rx1162_pos, rx1162_off
-    substr $S10, rx1162_tgt, $I11, 2
-    ne $S10, "+^", rx1162_fail
-    add rx1162_pos, 2
-    set_addr $I10, rxcap_1167_fail
-    ($I12, $I11) = rx1162_cur."!mark_peek"($I10)
-    rx1162_cur."!cursor_pos"($I11)
-    ($P10) = rx1162_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1162_pos, "")
-    rx1162_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1130_pos, 2
+    gt $I11, rx1130_eos, rx1130_fail
+    sub $I11, rx1130_pos, rx1130_off
+    substr $S10, rx1130_tgt, $I11, 2
+    ne $S10, "+^", rx1130_fail
+    add rx1130_pos, 2
+    set_addr $I10, rxcap_1135_fail
+    ($I12, $I11) = rx1130_cur."!mark_peek"($I10)
+    rx1130_cur."!cursor_pos"($I11)
+    ($P10) = rx1130_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1130_pos, "")
+    rx1130_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1167_done
-  rxcap_1167_fail:
-    goto rx1162_fail
-  rxcap_1167_done:
+    goto rxcap_1135_done
+  rxcap_1135_fail:
+    goto rx1130_fail
+  rxcap_1135_done:
   # rx subrule "O" subtype=capture negate=
-    rx1162_cur."!cursor_pos"(rx1162_pos)
-    $P10 = rx1162_cur."O"("%additive, :pirop<bxor III>")
-    unless $P10, rx1162_fail
-    rx1162_cur."!mark_push"(0, -1, 0, $P10)
+    rx1130_cur."!cursor_pos"(rx1130_pos)
+    $P10 = rx1130_cur."O"("%additive, :pirop<bxor III>")
+    unless $P10, rx1130_fail
+    rx1130_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1162_pos = $P10."pos"()
+    rx1130_pos = $P10."pos"()
   # rx pass
-    rx1162_cur."!cursor_pass"(rx1162_pos, "infix:sym<+^>")
-    rx1162_cur."!cursor_debug"("PASS  ", "infix:sym<+^>", " at pos=", rx1162_pos)
-    .return (rx1162_cur)
-  rx1162_fail:
+    rx1130_cur."!cursor_pass"(rx1130_pos, "infix:sym<+^>")
+    rx1130_cur."!cursor_debug"("PASS  ", "infix:sym<+^>", " at pos=", rx1130_pos)
+    .return (rx1130_cur)
+  rx1130_restart:
 .annotate 'line', 447
-    (rx1162_rep, rx1162_pos, $I10, $P10) = rx1162_cur."!mark_fail"(0)
-    lt rx1162_pos, -1, rx1162_done
-    eq rx1162_pos, -1, rx1162_fail
+    rx1130_cur."!cursor_debug"("NEXT ", "infix:sym<+^>")
+  rx1130_fail:
+    (rx1130_rep, rx1130_pos, $I10, $P10) = rx1130_cur."!mark_fail"(0)
+    lt rx1130_pos, -1, rx1130_done
+    eq rx1130_pos, -1, rx1130_fail
     jump $I10
-  rx1162_done:
-    rx1162_cur."!cursor_fail"()
-    rx1162_cur."!cursor_debug"("FAIL  ", "infix:sym<+^>")
-    .return (rx1162_cur)
+  rx1130_done:
+    rx1130_cur."!cursor_fail"()
+    rx1130_cur."!cursor_debug"("FAIL  ", "infix:sym<+^>")
+    .return (rx1130_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<+^>"  :subid("291_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<+^>"  :subid("291_1279529226.73787") :method
 .annotate 'line', 447
-    $P1164 = self."!PREFIX__!subrule"("O", "+^")
-    new $P1165, "ResizablePMCArray"
-    push $P1165, $P1164
-    .return ($P1165)
+    $P1132 = self."!PREFIX__!subrule"("O", "+^")
+    new $P1133, "ResizablePMCArray"
+    push $P1133, $P1132
+    .return ($P1133)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<~>"  :subid("292_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<~>"  :subid("292_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1169_tgt
-    .local int rx1169_pos
-    .local int rx1169_off
-    .local int rx1169_eos
-    .local int rx1169_rep
-    .local pmc rx1169_cur
-    (rx1169_cur, rx1169_pos, rx1169_tgt) = self."!cursor_start"()
-    rx1169_cur."!cursor_debug"("START ", "infix:sym<~>")
-    .lex unicode:"$\x{a2}", rx1169_cur
+    .local string rx1137_tgt
+    .local int rx1137_pos
+    .local int rx1137_off
+    .local int rx1137_eos
+    .local int rx1137_rep
+    .local pmc rx1137_cur
+    (rx1137_cur, rx1137_pos, rx1137_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1137_cur
     .local pmc match
     .lex "$/", match
-    length rx1169_eos, rx1169_tgt
-    gt rx1169_pos, rx1169_eos, rx1169_done
-    set rx1169_off, 0
-    lt rx1169_pos, 2, rx1169_start
-    sub rx1169_off, rx1169_pos, 1
-    substr rx1169_tgt, rx1169_tgt, rx1169_off
-  rx1169_start:
+    length rx1137_eos, rx1137_tgt
+    gt rx1137_pos, rx1137_eos, rx1137_done
+    set rx1137_off, 0
+    lt rx1137_pos, 2, rx1137_start
+    sub rx1137_off, rx1137_pos, 1
+    substr rx1137_tgt, rx1137_tgt, rx1137_off
+  rx1137_start:
+    eq $I10, 1, rx1137_restart
+    rx1137_cur."!cursor_debug"("START ", "infix:sym<~>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1173_done
-    goto rxscan1173_scan
-  rxscan1173_loop:
-    ($P10) = rx1169_cur."from"()
+    ne $I10, -1, rxscan1141_done
+    goto rxscan1141_scan
+  rxscan1141_loop:
+    ($P10) = rx1137_cur."from"()
     inc $P10
-    set rx1169_pos, $P10
-    ge rx1169_pos, rx1169_eos, rxscan1173_done
-  rxscan1173_scan:
-    set_addr $I10, rxscan1173_loop
-    rx1169_cur."!mark_push"(0, rx1169_pos, $I10)
-  rxscan1173_done:
+    set rx1137_pos, $P10
+    ge rx1137_pos, rx1137_eos, rxscan1141_done
+  rxscan1141_scan:
+    set_addr $I10, rxscan1141_loop
+    rx1137_cur."!mark_push"(0, rx1137_pos, $I10)
+  rxscan1141_done:
 .annotate 'line', 517
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1174_fail
-    rx1169_cur."!mark_push"(0, rx1169_pos, $I10)
+    set_addr $I10, rxcap_1142_fail
+    rx1137_cur."!mark_push"(0, rx1137_pos, $I10)
   # rx literal  "~"
-    add $I11, rx1169_pos, 1
-    gt $I11, rx1169_eos, rx1169_fail
-    sub $I11, rx1169_pos, rx1169_off
-    substr $S10, rx1169_tgt, $I11, 1
-    ne $S10, "~", rx1169_fail
-    add rx1169_pos, 1
-    set_addr $I10, rxcap_1174_fail
-    ($I12, $I11) = rx1169_cur."!mark_peek"($I10)
-    rx1169_cur."!cursor_pos"($I11)
-    ($P10) = rx1169_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1169_pos, "")
-    rx1169_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1137_pos, 1
+    gt $I11, rx1137_eos, rx1137_fail
+    sub $I11, rx1137_pos, rx1137_off
+    substr $S10, rx1137_tgt, $I11, 1
+    ne $S10, "~", rx1137_fail
+    add rx1137_pos, 1
+    set_addr $I10, rxcap_1142_fail
+    ($I12, $I11) = rx1137_cur."!mark_peek"($I10)
+    rx1137_cur."!cursor_pos"($I11)
+    ($P10) = rx1137_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1137_pos, "")
+    rx1137_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1174_done
-  rxcap_1174_fail:
-    goto rx1169_fail
-  rxcap_1174_done:
+    goto rxcap_1142_done
+  rxcap_1142_fail:
+    goto rx1137_fail
+  rxcap_1142_done:
   # rx subrule "O" subtype=capture negate=
-    rx1169_cur."!cursor_pos"(rx1169_pos)
-    $P10 = rx1169_cur."O"("%concatenation , :pirop<concat>")
-    unless $P10, rx1169_fail
-    rx1169_cur."!mark_push"(0, -1, 0, $P10)
+    rx1137_cur."!cursor_pos"(rx1137_pos)
+    $P10 = rx1137_cur."O"("%concatenation , :pirop<concat>")
+    unless $P10, rx1137_fail
+    rx1137_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1169_pos = $P10."pos"()
+    rx1137_pos = $P10."pos"()
   # rx pass
-    rx1169_cur."!cursor_pass"(rx1169_pos, "infix:sym<~>")
-    rx1169_cur."!cursor_debug"("PASS  ", "infix:sym<~>", " at pos=", rx1169_pos)
-    .return (rx1169_cur)
-  rx1169_fail:
+    rx1137_cur."!cursor_pass"(rx1137_pos, "infix:sym<~>")
+    rx1137_cur."!cursor_debug"("PASS  ", "infix:sym<~>", " at pos=", rx1137_pos)
+    .return (rx1137_cur)
+  rx1137_restart:
 .annotate 'line', 447
-    (rx1169_rep, rx1169_pos, $I10, $P10) = rx1169_cur."!mark_fail"(0)
-    lt rx1169_pos, -1, rx1169_done
-    eq rx1169_pos, -1, rx1169_fail
+    rx1137_cur."!cursor_debug"("NEXT ", "infix:sym<~>")
+  rx1137_fail:
+    (rx1137_rep, rx1137_pos, $I10, $P10) = rx1137_cur."!mark_fail"(0)
+    lt rx1137_pos, -1, rx1137_done
+    eq rx1137_pos, -1, rx1137_fail
     jump $I10
-  rx1169_done:
-    rx1169_cur."!cursor_fail"()
-    rx1169_cur."!cursor_debug"("FAIL  ", "infix:sym<~>")
-    .return (rx1169_cur)
+  rx1137_done:
+    rx1137_cur."!cursor_fail"()
+    rx1137_cur."!cursor_debug"("FAIL  ", "infix:sym<~>")
+    .return (rx1137_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<~>"  :subid("293_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<~>"  :subid("293_1279529226.73787") :method
 .annotate 'line', 447
-    $P1171 = self."!PREFIX__!subrule"("O", "~")
-    new $P1172, "ResizablePMCArray"
-    push $P1172, $P1171
-    .return ($P1172)
+    $P1139 = self."!PREFIX__!subrule"("O", "~")
+    new $P1140, "ResizablePMCArray"
+    push $P1140, $P1139
+    .return ($P1140)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<==>"  :subid("294_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<==>"  :subid("294_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1176_tgt
-    .local int rx1176_pos
-    .local int rx1176_off
-    .local int rx1176_eos
-    .local int rx1176_rep
-    .local pmc rx1176_cur
-    (rx1176_cur, rx1176_pos, rx1176_tgt) = self."!cursor_start"()
-    rx1176_cur."!cursor_debug"("START ", "infix:sym<==>")
-    .lex unicode:"$\x{a2}", rx1176_cur
+    .local string rx1144_tgt
+    .local int rx1144_pos
+    .local int rx1144_off
+    .local int rx1144_eos
+    .local int rx1144_rep
+    .local pmc rx1144_cur
+    (rx1144_cur, rx1144_pos, rx1144_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1144_cur
     .local pmc match
     .lex "$/", match
-    length rx1176_eos, rx1176_tgt
-    gt rx1176_pos, rx1176_eos, rx1176_done
-    set rx1176_off, 0
-    lt rx1176_pos, 2, rx1176_start
-    sub rx1176_off, rx1176_pos, 1
-    substr rx1176_tgt, rx1176_tgt, rx1176_off
-  rx1176_start:
+    length rx1144_eos, rx1144_tgt
+    gt rx1144_pos, rx1144_eos, rx1144_done
+    set rx1144_off, 0
+    lt rx1144_pos, 2, rx1144_start
+    sub rx1144_off, rx1144_pos, 1
+    substr rx1144_tgt, rx1144_tgt, rx1144_off
+  rx1144_start:
+    eq $I10, 1, rx1144_restart
+    rx1144_cur."!cursor_debug"("START ", "infix:sym<==>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1180_done
-    goto rxscan1180_scan
-  rxscan1180_loop:
-    ($P10) = rx1176_cur."from"()
+    ne $I10, -1, rxscan1148_done
+    goto rxscan1148_scan
+  rxscan1148_loop:
+    ($P10) = rx1144_cur."from"()
     inc $P10
-    set rx1176_pos, $P10
-    ge rx1176_pos, rx1176_eos, rxscan1180_done
-  rxscan1180_scan:
-    set_addr $I10, rxscan1180_loop
-    rx1176_cur."!mark_push"(0, rx1176_pos, $I10)
-  rxscan1180_done:
+    set rx1144_pos, $P10
+    ge rx1144_pos, rx1144_eos, rxscan1148_done
+  rxscan1148_scan:
+    set_addr $I10, rxscan1148_loop
+    rx1144_cur."!mark_push"(0, rx1144_pos, $I10)
+  rxscan1148_done:
 .annotate 'line', 519
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1181_fail
-    rx1176_cur."!mark_push"(0, rx1176_pos, $I10)
+    set_addr $I10, rxcap_1149_fail
+    rx1144_cur."!mark_push"(0, rx1144_pos, $I10)
   # rx literal  "=="
-    add $I11, rx1176_pos, 2
-    gt $I11, rx1176_eos, rx1176_fail
-    sub $I11, rx1176_pos, rx1176_off
-    substr $S10, rx1176_tgt, $I11, 2
-    ne $S10, "==", rx1176_fail
-    add rx1176_pos, 2
-    set_addr $I10, rxcap_1181_fail
-    ($I12, $I11) = rx1176_cur."!mark_peek"($I10)
-    rx1176_cur."!cursor_pos"($I11)
-    ($P10) = rx1176_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1176_pos, "")
-    rx1176_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1144_pos, 2
+    gt $I11, rx1144_eos, rx1144_fail
+    sub $I11, rx1144_pos, rx1144_off
+    substr $S10, rx1144_tgt, $I11, 2
+    ne $S10, "==", rx1144_fail
+    add rx1144_pos, 2
+    set_addr $I10, rxcap_1149_fail
+    ($I12, $I11) = rx1144_cur."!mark_peek"($I10)
+    rx1144_cur."!cursor_pos"($I11)
+    ($P10) = rx1144_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1144_pos, "")
+    rx1144_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1181_done
-  rxcap_1181_fail:
-    goto rx1176_fail
-  rxcap_1181_done:
+    goto rxcap_1149_done
+  rxcap_1149_fail:
+    goto rx1144_fail
+  rxcap_1149_done:
   # rx subrule "O" subtype=capture negate=
-    rx1176_cur."!cursor_pos"(rx1176_pos)
-    $P10 = rx1176_cur."O"("%relational, :pirop<iseq INn>")
-    unless $P10, rx1176_fail
-    rx1176_cur."!mark_push"(0, -1, 0, $P10)
+    rx1144_cur."!cursor_pos"(rx1144_pos)
+    $P10 = rx1144_cur."O"("%relational, :pirop<iseq INn>")
+    unless $P10, rx1144_fail
+    rx1144_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1176_pos = $P10."pos"()
+    rx1144_pos = $P10."pos"()
   # rx pass
-    rx1176_cur."!cursor_pass"(rx1176_pos, "infix:sym<==>")
-    rx1176_cur."!cursor_debug"("PASS  ", "infix:sym<==>", " at pos=", rx1176_pos)
-    .return (rx1176_cur)
-  rx1176_fail:
+    rx1144_cur."!cursor_pass"(rx1144_pos, "infix:sym<==>")
+    rx1144_cur."!cursor_debug"("PASS  ", "infix:sym<==>", " at pos=", rx1144_pos)
+    .return (rx1144_cur)
+  rx1144_restart:
 .annotate 'line', 447
-    (rx1176_rep, rx1176_pos, $I10, $P10) = rx1176_cur."!mark_fail"(0)
-    lt rx1176_pos, -1, rx1176_done
-    eq rx1176_pos, -1, rx1176_fail
+    rx1144_cur."!cursor_debug"("NEXT ", "infix:sym<==>")
+  rx1144_fail:
+    (rx1144_rep, rx1144_pos, $I10, $P10) = rx1144_cur."!mark_fail"(0)
+    lt rx1144_pos, -1, rx1144_done
+    eq rx1144_pos, -1, rx1144_fail
     jump $I10
-  rx1176_done:
-    rx1176_cur."!cursor_fail"()
-    rx1176_cur."!cursor_debug"("FAIL  ", "infix:sym<==>")
-    .return (rx1176_cur)
+  rx1144_done:
+    rx1144_cur."!cursor_fail"()
+    rx1144_cur."!cursor_debug"("FAIL  ", "infix:sym<==>")
+    .return (rx1144_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<==>"  :subid("295_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<==>"  :subid("295_1279529226.73787") :method
 .annotate 'line', 447
-    $P1178 = self."!PREFIX__!subrule"("O", "==")
-    new $P1179, "ResizablePMCArray"
-    push $P1179, $P1178
-    .return ($P1179)
+    $P1146 = self."!PREFIX__!subrule"("O", "==")
+    new $P1147, "ResizablePMCArray"
+    push $P1147, $P1146
+    .return ($P1147)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<!=>"  :subid("296_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<!=>"  :subid("296_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1183_tgt
-    .local int rx1183_pos
-    .local int rx1183_off
-    .local int rx1183_eos
-    .local int rx1183_rep
-    .local pmc rx1183_cur
-    (rx1183_cur, rx1183_pos, rx1183_tgt) = self."!cursor_start"()
-    rx1183_cur."!cursor_debug"("START ", "infix:sym<!=>")
-    .lex unicode:"$\x{a2}", rx1183_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1183_eos, rx1183_tgt
-    gt rx1183_pos, rx1183_eos, rx1183_done
-    set rx1183_off, 0
-    lt rx1183_pos, 2, rx1183_start
-    sub rx1183_off, rx1183_pos, 1
-    substr rx1183_tgt, rx1183_tgt, rx1183_off
-  rx1183_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1187_done
-    goto rxscan1187_scan
-  rxscan1187_loop:
-    ($P10) = rx1183_cur."from"()
-    inc $P10
-    set rx1183_pos, $P10
-    ge rx1183_pos, rx1183_eos, rxscan1187_done
-  rxscan1187_scan:
-    set_addr $I10, rxscan1187_loop
-    rx1183_cur."!mark_push"(0, rx1183_pos, $I10)
-  rxscan1187_done:
+    .local string rx1151_tgt
+    .local int rx1151_pos
+    .local int rx1151_off
+    .local int rx1151_eos
+    .local int rx1151_rep
+    .local pmc rx1151_cur
+    (rx1151_cur, rx1151_pos, rx1151_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1151_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1151_eos, rx1151_tgt
+    gt rx1151_pos, rx1151_eos, rx1151_done
+    set rx1151_off, 0
+    lt rx1151_pos, 2, rx1151_start
+    sub rx1151_off, rx1151_pos, 1
+    substr rx1151_tgt, rx1151_tgt, rx1151_off
+  rx1151_start:
+    eq $I10, 1, rx1151_restart
+    rx1151_cur."!cursor_debug"("START ", "infix:sym<!=>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1155_done
+    goto rxscan1155_scan
+  rxscan1155_loop:
+    ($P10) = rx1151_cur."from"()
+    inc $P10
+    set rx1151_pos, $P10
+    ge rx1151_pos, rx1151_eos, rxscan1155_done
+  rxscan1155_scan:
+    set_addr $I10, rxscan1155_loop
+    rx1151_cur."!mark_push"(0, rx1151_pos, $I10)
+  rxscan1155_done:
 .annotate 'line', 520
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1188_fail
-    rx1183_cur."!mark_push"(0, rx1183_pos, $I10)
+    set_addr $I10, rxcap_1156_fail
+    rx1151_cur."!mark_push"(0, rx1151_pos, $I10)
   # rx literal  "!="
-    add $I11, rx1183_pos, 2
-    gt $I11, rx1183_eos, rx1183_fail
-    sub $I11, rx1183_pos, rx1183_off
-    substr $S10, rx1183_tgt, $I11, 2
-    ne $S10, "!=", rx1183_fail
-    add rx1183_pos, 2
-    set_addr $I10, rxcap_1188_fail
-    ($I12, $I11) = rx1183_cur."!mark_peek"($I10)
-    rx1183_cur."!cursor_pos"($I11)
-    ($P10) = rx1183_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1183_pos, "")
-    rx1183_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1151_pos, 2
+    gt $I11, rx1151_eos, rx1151_fail
+    sub $I11, rx1151_pos, rx1151_off
+    substr $S10, rx1151_tgt, $I11, 2
+    ne $S10, "!=", rx1151_fail
+    add rx1151_pos, 2
+    set_addr $I10, rxcap_1156_fail
+    ($I12, $I11) = rx1151_cur."!mark_peek"($I10)
+    rx1151_cur."!cursor_pos"($I11)
+    ($P10) = rx1151_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1151_pos, "")
+    rx1151_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1188_done
-  rxcap_1188_fail:
-    goto rx1183_fail
-  rxcap_1188_done:
+    goto rxcap_1156_done
+  rxcap_1156_fail:
+    goto rx1151_fail
+  rxcap_1156_done:
   # rx subrule "O" subtype=capture negate=
-    rx1183_cur."!cursor_pos"(rx1183_pos)
-    $P10 = rx1183_cur."O"("%relational, :pirop<isne INn>")
-    unless $P10, rx1183_fail
-    rx1183_cur."!mark_push"(0, -1, 0, $P10)
+    rx1151_cur."!cursor_pos"(rx1151_pos)
+    $P10 = rx1151_cur."O"("%relational, :pirop<isne INn>")
+    unless $P10, rx1151_fail
+    rx1151_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1183_pos = $P10."pos"()
+    rx1151_pos = $P10."pos"()
   # rx pass
-    rx1183_cur."!cursor_pass"(rx1183_pos, "infix:sym<!=>")
-    rx1183_cur."!cursor_debug"("PASS  ", "infix:sym<!=>", " at pos=", rx1183_pos)
-    .return (rx1183_cur)
-  rx1183_fail:
+    rx1151_cur."!cursor_pass"(rx1151_pos, "infix:sym<!=>")
+    rx1151_cur."!cursor_debug"("PASS  ", "infix:sym<!=>", " at pos=", rx1151_pos)
+    .return (rx1151_cur)
+  rx1151_restart:
 .annotate 'line', 447
-    (rx1183_rep, rx1183_pos, $I10, $P10) = rx1183_cur."!mark_fail"(0)
-    lt rx1183_pos, -1, rx1183_done
-    eq rx1183_pos, -1, rx1183_fail
+    rx1151_cur."!cursor_debug"("NEXT ", "infix:sym<!=>")
+  rx1151_fail:
+    (rx1151_rep, rx1151_pos, $I10, $P10) = rx1151_cur."!mark_fail"(0)
+    lt rx1151_pos, -1, rx1151_done
+    eq rx1151_pos, -1, rx1151_fail
     jump $I10
-  rx1183_done:
-    rx1183_cur."!cursor_fail"()
-    rx1183_cur."!cursor_debug"("FAIL  ", "infix:sym<!=>")
-    .return (rx1183_cur)
+  rx1151_done:
+    rx1151_cur."!cursor_fail"()
+    rx1151_cur."!cursor_debug"("FAIL  ", "infix:sym<!=>")
+    .return (rx1151_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<!=>"  :subid("297_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<!=>"  :subid("297_1279529226.73787") :method
 .annotate 'line', 447
-    $P1185 = self."!PREFIX__!subrule"("O", "!=")
-    new $P1186, "ResizablePMCArray"
-    push $P1186, $P1185
-    .return ($P1186)
+    $P1153 = self."!PREFIX__!subrule"("O", "!=")
+    new $P1154, "ResizablePMCArray"
+    push $P1154, $P1153
+    .return ($P1154)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<<=>"  :subid("298_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<<=>"  :subid("298_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1190_tgt
-    .local int rx1190_pos
-    .local int rx1190_off
-    .local int rx1190_eos
-    .local int rx1190_rep
-    .local pmc rx1190_cur
-    (rx1190_cur, rx1190_pos, rx1190_tgt) = self."!cursor_start"()
-    rx1190_cur."!cursor_debug"("START ", "infix:sym<<=>")
-    .lex unicode:"$\x{a2}", rx1190_cur
+    .local string rx1158_tgt
+    .local int rx1158_pos
+    .local int rx1158_off
+    .local int rx1158_eos
+    .local int rx1158_rep
+    .local pmc rx1158_cur
+    (rx1158_cur, rx1158_pos, rx1158_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1158_cur
     .local pmc match
     .lex "$/", match
-    length rx1190_eos, rx1190_tgt
-    gt rx1190_pos, rx1190_eos, rx1190_done
-    set rx1190_off, 0
-    lt rx1190_pos, 2, rx1190_start
-    sub rx1190_off, rx1190_pos, 1
-    substr rx1190_tgt, rx1190_tgt, rx1190_off
-  rx1190_start:
+    length rx1158_eos, rx1158_tgt
+    gt rx1158_pos, rx1158_eos, rx1158_done
+    set rx1158_off, 0
+    lt rx1158_pos, 2, rx1158_start
+    sub rx1158_off, rx1158_pos, 1
+    substr rx1158_tgt, rx1158_tgt, rx1158_off
+  rx1158_start:
+    eq $I10, 1, rx1158_restart
+    rx1158_cur."!cursor_debug"("START ", "infix:sym<<=>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1194_done
-    goto rxscan1194_scan
-  rxscan1194_loop:
-    ($P10) = rx1190_cur."from"()
+    ne $I10, -1, rxscan1162_done
+    goto rxscan1162_scan
+  rxscan1162_loop:
+    ($P10) = rx1158_cur."from"()
     inc $P10
-    set rx1190_pos, $P10
-    ge rx1190_pos, rx1190_eos, rxscan1194_done
-  rxscan1194_scan:
-    set_addr $I10, rxscan1194_loop
-    rx1190_cur."!mark_push"(0, rx1190_pos, $I10)
-  rxscan1194_done:
+    set rx1158_pos, $P10
+    ge rx1158_pos, rx1158_eos, rxscan1162_done
+  rxscan1162_scan:
+    set_addr $I10, rxscan1162_loop
+    rx1158_cur."!mark_push"(0, rx1158_pos, $I10)
+  rxscan1162_done:
 .annotate 'line', 521
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1195_fail
-    rx1190_cur."!mark_push"(0, rx1190_pos, $I10)
+    set_addr $I10, rxcap_1163_fail
+    rx1158_cur."!mark_push"(0, rx1158_pos, $I10)
   # rx literal  "<="
-    add $I11, rx1190_pos, 2
-    gt $I11, rx1190_eos, rx1190_fail
-    sub $I11, rx1190_pos, rx1190_off
-    substr $S10, rx1190_tgt, $I11, 2
-    ne $S10, "<=", rx1190_fail
-    add rx1190_pos, 2
-    set_addr $I10, rxcap_1195_fail
-    ($I12, $I11) = rx1190_cur."!mark_peek"($I10)
-    rx1190_cur."!cursor_pos"($I11)
-    ($P10) = rx1190_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1190_pos, "")
-    rx1190_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1158_pos, 2
+    gt $I11, rx1158_eos, rx1158_fail
+    sub $I11, rx1158_pos, rx1158_off
+    substr $S10, rx1158_tgt, $I11, 2
+    ne $S10, "<=", rx1158_fail
+    add rx1158_pos, 2
+    set_addr $I10, rxcap_1163_fail
+    ($I12, $I11) = rx1158_cur."!mark_peek"($I10)
+    rx1158_cur."!cursor_pos"($I11)
+    ($P10) = rx1158_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1158_pos, "")
+    rx1158_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1195_done
-  rxcap_1195_fail:
-    goto rx1190_fail
-  rxcap_1195_done:
+    goto rxcap_1163_done
+  rxcap_1163_fail:
+    goto rx1158_fail
+  rxcap_1163_done:
   # rx subrule "O" subtype=capture negate=
-    rx1190_cur."!cursor_pos"(rx1190_pos)
-    $P10 = rx1190_cur."O"("%relational, :pirop<isle INn>")
-    unless $P10, rx1190_fail
-    rx1190_cur."!mark_push"(0, -1, 0, $P10)
+    rx1158_cur."!cursor_pos"(rx1158_pos)
+    $P10 = rx1158_cur."O"("%relational, :pirop<isle INn>")
+    unless $P10, rx1158_fail
+    rx1158_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1190_pos = $P10."pos"()
+    rx1158_pos = $P10."pos"()
   # rx pass
-    rx1190_cur."!cursor_pass"(rx1190_pos, "infix:sym<<=>")
-    rx1190_cur."!cursor_debug"("PASS  ", "infix:sym<<=>", " at pos=", rx1190_pos)
-    .return (rx1190_cur)
-  rx1190_fail:
+    rx1158_cur."!cursor_pass"(rx1158_pos, "infix:sym<<=>")
+    rx1158_cur."!cursor_debug"("PASS  ", "infix:sym<<=>", " at pos=", rx1158_pos)
+    .return (rx1158_cur)
+  rx1158_restart:
 .annotate 'line', 447
-    (rx1190_rep, rx1190_pos, $I10, $P10) = rx1190_cur."!mark_fail"(0)
-    lt rx1190_pos, -1, rx1190_done
-    eq rx1190_pos, -1, rx1190_fail
+    rx1158_cur."!cursor_debug"("NEXT ", "infix:sym<<=>")
+  rx1158_fail:
+    (rx1158_rep, rx1158_pos, $I10, $P10) = rx1158_cur."!mark_fail"(0)
+    lt rx1158_pos, -1, rx1158_done
+    eq rx1158_pos, -1, rx1158_fail
     jump $I10
-  rx1190_done:
-    rx1190_cur."!cursor_fail"()
-    rx1190_cur."!cursor_debug"("FAIL  ", "infix:sym<<=>")
-    .return (rx1190_cur)
+  rx1158_done:
+    rx1158_cur."!cursor_fail"()
+    rx1158_cur."!cursor_debug"("FAIL  ", "infix:sym<<=>")
+    .return (rx1158_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<<=>"  :subid("299_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<<=>"  :subid("299_1279529226.73787") :method
 .annotate 'line', 447
-    $P1192 = self."!PREFIX__!subrule"("O", "<=")
-    new $P1193, "ResizablePMCArray"
-    push $P1193, $P1192
-    .return ($P1193)
+    $P1160 = self."!PREFIX__!subrule"("O", "<=")
+    new $P1161, "ResizablePMCArray"
+    push $P1161, $P1160
+    .return ($P1161)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<>=>"  :subid("300_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<>=>"  :subid("300_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1197_tgt
-    .local int rx1197_pos
-    .local int rx1197_off
-    .local int rx1197_eos
-    .local int rx1197_rep
-    .local pmc rx1197_cur
-    (rx1197_cur, rx1197_pos, rx1197_tgt) = self."!cursor_start"()
-    rx1197_cur."!cursor_debug"("START ", "infix:sym<>=>")
-    .lex unicode:"$\x{a2}", rx1197_cur
+    .local string rx1165_tgt
+    .local int rx1165_pos
+    .local int rx1165_off
+    .local int rx1165_eos
+    .local int rx1165_rep
+    .local pmc rx1165_cur
+    (rx1165_cur, rx1165_pos, rx1165_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1165_cur
     .local pmc match
     .lex "$/", match
-    length rx1197_eos, rx1197_tgt
-    gt rx1197_pos, rx1197_eos, rx1197_done
-    set rx1197_off, 0
-    lt rx1197_pos, 2, rx1197_start
-    sub rx1197_off, rx1197_pos, 1
-    substr rx1197_tgt, rx1197_tgt, rx1197_off
-  rx1197_start:
+    length rx1165_eos, rx1165_tgt
+    gt rx1165_pos, rx1165_eos, rx1165_done
+    set rx1165_off, 0
+    lt rx1165_pos, 2, rx1165_start
+    sub rx1165_off, rx1165_pos, 1
+    substr rx1165_tgt, rx1165_tgt, rx1165_off
+  rx1165_start:
+    eq $I10, 1, rx1165_restart
+    rx1165_cur."!cursor_debug"("START ", "infix:sym<>=>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1201_done
-    goto rxscan1201_scan
-  rxscan1201_loop:
-    ($P10) = rx1197_cur."from"()
+    ne $I10, -1, rxscan1169_done
+    goto rxscan1169_scan
+  rxscan1169_loop:
+    ($P10) = rx1165_cur."from"()
     inc $P10
-    set rx1197_pos, $P10
-    ge rx1197_pos, rx1197_eos, rxscan1201_done
-  rxscan1201_scan:
-    set_addr $I10, rxscan1201_loop
-    rx1197_cur."!mark_push"(0, rx1197_pos, $I10)
-  rxscan1201_done:
+    set rx1165_pos, $P10
+    ge rx1165_pos, rx1165_eos, rxscan1169_done
+  rxscan1169_scan:
+    set_addr $I10, rxscan1169_loop
+    rx1165_cur."!mark_push"(0, rx1165_pos, $I10)
+  rxscan1169_done:
 .annotate 'line', 522
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1202_fail
-    rx1197_cur."!mark_push"(0, rx1197_pos, $I10)
+    set_addr $I10, rxcap_1170_fail
+    rx1165_cur."!mark_push"(0, rx1165_pos, $I10)
   # rx literal  ">="
-    add $I11, rx1197_pos, 2
-    gt $I11, rx1197_eos, rx1197_fail
-    sub $I11, rx1197_pos, rx1197_off
-    substr $S10, rx1197_tgt, $I11, 2
-    ne $S10, ">=", rx1197_fail
-    add rx1197_pos, 2
-    set_addr $I10, rxcap_1202_fail
-    ($I12, $I11) = rx1197_cur."!mark_peek"($I10)
-    rx1197_cur."!cursor_pos"($I11)
-    ($P10) = rx1197_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1197_pos, "")
-    rx1197_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1165_pos, 2
+    gt $I11, rx1165_eos, rx1165_fail
+    sub $I11, rx1165_pos, rx1165_off
+    substr $S10, rx1165_tgt, $I11, 2
+    ne $S10, ">=", rx1165_fail
+    add rx1165_pos, 2
+    set_addr $I10, rxcap_1170_fail
+    ($I12, $I11) = rx1165_cur."!mark_peek"($I10)
+    rx1165_cur."!cursor_pos"($I11)
+    ($P10) = rx1165_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1165_pos, "")
+    rx1165_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1202_done
-  rxcap_1202_fail:
-    goto rx1197_fail
-  rxcap_1202_done:
+    goto rxcap_1170_done
+  rxcap_1170_fail:
+    goto rx1165_fail
+  rxcap_1170_done:
   # rx subrule "O" subtype=capture negate=
-    rx1197_cur."!cursor_pos"(rx1197_pos)
-    $P10 = rx1197_cur."O"("%relational, :pirop<isge INn>")
-    unless $P10, rx1197_fail
-    rx1197_cur."!mark_push"(0, -1, 0, $P10)
+    rx1165_cur."!cursor_pos"(rx1165_pos)
+    $P10 = rx1165_cur."O"("%relational, :pirop<isge INn>")
+    unless $P10, rx1165_fail
+    rx1165_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1197_pos = $P10."pos"()
+    rx1165_pos = $P10."pos"()
   # rx pass
-    rx1197_cur."!cursor_pass"(rx1197_pos, "infix:sym<>=>")
-    rx1197_cur."!cursor_debug"("PASS  ", "infix:sym<>=>", " at pos=", rx1197_pos)
-    .return (rx1197_cur)
-  rx1197_fail:
+    rx1165_cur."!cursor_pass"(rx1165_pos, "infix:sym<>=>")
+    rx1165_cur."!cursor_debug"("PASS  ", "infix:sym<>=>", " at pos=", rx1165_pos)
+    .return (rx1165_cur)
+  rx1165_restart:
 .annotate 'line', 447
-    (rx1197_rep, rx1197_pos, $I10, $P10) = rx1197_cur."!mark_fail"(0)
-    lt rx1197_pos, -1, rx1197_done
-    eq rx1197_pos, -1, rx1197_fail
+    rx1165_cur."!cursor_debug"("NEXT ", "infix:sym<>=>")
+  rx1165_fail:
+    (rx1165_rep, rx1165_pos, $I10, $P10) = rx1165_cur."!mark_fail"(0)
+    lt rx1165_pos, -1, rx1165_done
+    eq rx1165_pos, -1, rx1165_fail
     jump $I10
-  rx1197_done:
-    rx1197_cur."!cursor_fail"()
-    rx1197_cur."!cursor_debug"("FAIL  ", "infix:sym<>=>")
-    .return (rx1197_cur)
+  rx1165_done:
+    rx1165_cur."!cursor_fail"()
+    rx1165_cur."!cursor_debug"("FAIL  ", "infix:sym<>=>")
+    .return (rx1165_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<>=>"  :subid("301_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<>=>"  :subid("301_1279529226.73787") :method
 .annotate 'line', 447
-    $P1199 = self."!PREFIX__!subrule"("O", ">=")
-    new $P1200, "ResizablePMCArray"
-    push $P1200, $P1199
-    .return ($P1200)
+    $P1167 = self."!PREFIX__!subrule"("O", ">=")
+    new $P1168, "ResizablePMCArray"
+    push $P1168, $P1167
+    .return ($P1168)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<<>"  :subid("302_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<<>"  :subid("302_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1204_tgt
-    .local int rx1204_pos
-    .local int rx1204_off
-    .local int rx1204_eos
-    .local int rx1204_rep
-    .local pmc rx1204_cur
-    (rx1204_cur, rx1204_pos, rx1204_tgt) = self."!cursor_start"()
-    rx1204_cur."!cursor_debug"("START ", "infix:sym<<>")
-    .lex unicode:"$\x{a2}", rx1204_cur
+    .local string rx1172_tgt
+    .local int rx1172_pos
+    .local int rx1172_off
+    .local int rx1172_eos
+    .local int rx1172_rep
+    .local pmc rx1172_cur
+    (rx1172_cur, rx1172_pos, rx1172_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1172_cur
     .local pmc match
     .lex "$/", match
-    length rx1204_eos, rx1204_tgt
-    gt rx1204_pos, rx1204_eos, rx1204_done
-    set rx1204_off, 0
-    lt rx1204_pos, 2, rx1204_start
-    sub rx1204_off, rx1204_pos, 1
-    substr rx1204_tgt, rx1204_tgt, rx1204_off
-  rx1204_start:
+    length rx1172_eos, rx1172_tgt
+    gt rx1172_pos, rx1172_eos, rx1172_done
+    set rx1172_off, 0
+    lt rx1172_pos, 2, rx1172_start
+    sub rx1172_off, rx1172_pos, 1
+    substr rx1172_tgt, rx1172_tgt, rx1172_off
+  rx1172_start:
+    eq $I10, 1, rx1172_restart
+    rx1172_cur."!cursor_debug"("START ", "infix:sym<<>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1208_done
-    goto rxscan1208_scan
-  rxscan1208_loop:
-    ($P10) = rx1204_cur."from"()
+    ne $I10, -1, rxscan1176_done
+    goto rxscan1176_scan
+  rxscan1176_loop:
+    ($P10) = rx1172_cur."from"()
     inc $P10
-    set rx1204_pos, $P10
-    ge rx1204_pos, rx1204_eos, rxscan1208_done
-  rxscan1208_scan:
-    set_addr $I10, rxscan1208_loop
-    rx1204_cur."!mark_push"(0, rx1204_pos, $I10)
-  rxscan1208_done:
+    set rx1172_pos, $P10
+    ge rx1172_pos, rx1172_eos, rxscan1176_done
+  rxscan1176_scan:
+    set_addr $I10, rxscan1176_loop
+    rx1172_cur."!mark_push"(0, rx1172_pos, $I10)
+  rxscan1176_done:
 .annotate 'line', 523
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1209_fail
-    rx1204_cur."!mark_push"(0, rx1204_pos, $I10)
+    set_addr $I10, rxcap_1177_fail
+    rx1172_cur."!mark_push"(0, rx1172_pos, $I10)
   # rx literal  "<"
-    add $I11, rx1204_pos, 1
-    gt $I11, rx1204_eos, rx1204_fail
-    sub $I11, rx1204_pos, rx1204_off
-    substr $S10, rx1204_tgt, $I11, 1
-    ne $S10, "<", rx1204_fail
-    add rx1204_pos, 1
-    set_addr $I10, rxcap_1209_fail
-    ($I12, $I11) = rx1204_cur."!mark_peek"($I10)
-    rx1204_cur."!cursor_pos"($I11)
-    ($P10) = rx1204_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1204_pos, "")
-    rx1204_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1172_pos, 1
+    gt $I11, rx1172_eos, rx1172_fail
+    sub $I11, rx1172_pos, rx1172_off
+    substr $S10, rx1172_tgt, $I11, 1
+    ne $S10, "<", rx1172_fail
+    add rx1172_pos, 1
+    set_addr $I10, rxcap_1177_fail
+    ($I12, $I11) = rx1172_cur."!mark_peek"($I10)
+    rx1172_cur."!cursor_pos"($I11)
+    ($P10) = rx1172_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1172_pos, "")
+    rx1172_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1209_done
-  rxcap_1209_fail:
-    goto rx1204_fail
-  rxcap_1209_done:
+    goto rxcap_1177_done
+  rxcap_1177_fail:
+    goto rx1172_fail
+  rxcap_1177_done:
   # rx subrule "O" subtype=capture negate=
-    rx1204_cur."!cursor_pos"(rx1204_pos)
-    $P10 = rx1204_cur."O"("%relational, :pirop<islt INn>")
-    unless $P10, rx1204_fail
-    rx1204_cur."!mark_push"(0, -1, 0, $P10)
+    rx1172_cur."!cursor_pos"(rx1172_pos)
+    $P10 = rx1172_cur."O"("%relational, :pirop<islt INn>")
+    unless $P10, rx1172_fail
+    rx1172_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1204_pos = $P10."pos"()
+    rx1172_pos = $P10."pos"()
   # rx pass
-    rx1204_cur."!cursor_pass"(rx1204_pos, "infix:sym<<>")
-    rx1204_cur."!cursor_debug"("PASS  ", "infix:sym<<>", " at pos=", rx1204_pos)
-    .return (rx1204_cur)
-  rx1204_fail:
+    rx1172_cur."!cursor_pass"(rx1172_pos, "infix:sym<<>")
+    rx1172_cur."!cursor_debug"("PASS  ", "infix:sym<<>", " at pos=", rx1172_pos)
+    .return (rx1172_cur)
+  rx1172_restart:
 .annotate 'line', 447
-    (rx1204_rep, rx1204_pos, $I10, $P10) = rx1204_cur."!mark_fail"(0)
-    lt rx1204_pos, -1, rx1204_done
-    eq rx1204_pos, -1, rx1204_fail
+    rx1172_cur."!cursor_debug"("NEXT ", "infix:sym<<>")
+  rx1172_fail:
+    (rx1172_rep, rx1172_pos, $I10, $P10) = rx1172_cur."!mark_fail"(0)
+    lt rx1172_pos, -1, rx1172_done
+    eq rx1172_pos, -1, rx1172_fail
     jump $I10
-  rx1204_done:
-    rx1204_cur."!cursor_fail"()
-    rx1204_cur."!cursor_debug"("FAIL  ", "infix:sym<<>")
-    .return (rx1204_cur)
+  rx1172_done:
+    rx1172_cur."!cursor_fail"()
+    rx1172_cur."!cursor_debug"("FAIL  ", "infix:sym<<>")
+    .return (rx1172_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<<>"  :subid("303_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<<>"  :subid("303_1279529226.73787") :method
 .annotate 'line', 447
-    $P1206 = self."!PREFIX__!subrule"("O", "<")
-    new $P1207, "ResizablePMCArray"
-    push $P1207, $P1206
-    .return ($P1207)
+    $P1174 = self."!PREFIX__!subrule"("O", "<")
+    new $P1175, "ResizablePMCArray"
+    push $P1175, $P1174
+    .return ($P1175)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<>>"  :subid("304_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<>>"  :subid("304_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1211_tgt
-    .local int rx1211_pos
-    .local int rx1211_off
-    .local int rx1211_eos
-    .local int rx1211_rep
-    .local pmc rx1211_cur
-    (rx1211_cur, rx1211_pos, rx1211_tgt) = self."!cursor_start"()
-    rx1211_cur."!cursor_debug"("START ", "infix:sym<>>")
-    .lex unicode:"$\x{a2}", rx1211_cur
+    .local string rx1179_tgt
+    .local int rx1179_pos
+    .local int rx1179_off
+    .local int rx1179_eos
+    .local int rx1179_rep
+    .local pmc rx1179_cur
+    (rx1179_cur, rx1179_pos, rx1179_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1179_cur
     .local pmc match
     .lex "$/", match
-    length rx1211_eos, rx1211_tgt
-    gt rx1211_pos, rx1211_eos, rx1211_done
-    set rx1211_off, 0
-    lt rx1211_pos, 2, rx1211_start
-    sub rx1211_off, rx1211_pos, 1
-    substr rx1211_tgt, rx1211_tgt, rx1211_off
-  rx1211_start:
+    length rx1179_eos, rx1179_tgt
+    gt rx1179_pos, rx1179_eos, rx1179_done
+    set rx1179_off, 0
+    lt rx1179_pos, 2, rx1179_start
+    sub rx1179_off, rx1179_pos, 1
+    substr rx1179_tgt, rx1179_tgt, rx1179_off
+  rx1179_start:
+    eq $I10, 1, rx1179_restart
+    rx1179_cur."!cursor_debug"("START ", "infix:sym<>>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1215_done
-    goto rxscan1215_scan
-  rxscan1215_loop:
-    ($P10) = rx1211_cur."from"()
+    ne $I10, -1, rxscan1183_done
+    goto rxscan1183_scan
+  rxscan1183_loop:
+    ($P10) = rx1179_cur."from"()
     inc $P10
-    set rx1211_pos, $P10
-    ge rx1211_pos, rx1211_eos, rxscan1215_done
-  rxscan1215_scan:
-    set_addr $I10, rxscan1215_loop
-    rx1211_cur."!mark_push"(0, rx1211_pos, $I10)
-  rxscan1215_done:
+    set rx1179_pos, $P10
+    ge rx1179_pos, rx1179_eos, rxscan1183_done
+  rxscan1183_scan:
+    set_addr $I10, rxscan1183_loop
+    rx1179_cur."!mark_push"(0, rx1179_pos, $I10)
+  rxscan1183_done:
 .annotate 'line', 524
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1216_fail
-    rx1211_cur."!mark_push"(0, rx1211_pos, $I10)
+    set_addr $I10, rxcap_1184_fail
+    rx1179_cur."!mark_push"(0, rx1179_pos, $I10)
   # rx literal  ">"
-    add $I11, rx1211_pos, 1
-    gt $I11, rx1211_eos, rx1211_fail
-    sub $I11, rx1211_pos, rx1211_off
-    substr $S10, rx1211_tgt, $I11, 1
-    ne $S10, ">", rx1211_fail
-    add rx1211_pos, 1
-    set_addr $I10, rxcap_1216_fail
-    ($I12, $I11) = rx1211_cur."!mark_peek"($I10)
-    rx1211_cur."!cursor_pos"($I11)
-    ($P10) = rx1211_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1211_pos, "")
-    rx1211_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1179_pos, 1
+    gt $I11, rx1179_eos, rx1179_fail
+    sub $I11, rx1179_pos, rx1179_off
+    substr $S10, rx1179_tgt, $I11, 1
+    ne $S10, ">", rx1179_fail
+    add rx1179_pos, 1
+    set_addr $I10, rxcap_1184_fail
+    ($I12, $I11) = rx1179_cur."!mark_peek"($I10)
+    rx1179_cur."!cursor_pos"($I11)
+    ($P10) = rx1179_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1179_pos, "")
+    rx1179_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1216_done
-  rxcap_1216_fail:
-    goto rx1211_fail
-  rxcap_1216_done:
+    goto rxcap_1184_done
+  rxcap_1184_fail:
+    goto rx1179_fail
+  rxcap_1184_done:
   # rx subrule "O" subtype=capture negate=
-    rx1211_cur."!cursor_pos"(rx1211_pos)
-    $P10 = rx1211_cur."O"("%relational, :pirop<isgt INn>")
-    unless $P10, rx1211_fail
-    rx1211_cur."!mark_push"(0, -1, 0, $P10)
+    rx1179_cur."!cursor_pos"(rx1179_pos)
+    $P10 = rx1179_cur."O"("%relational, :pirop<isgt INn>")
+    unless $P10, rx1179_fail
+    rx1179_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1211_pos = $P10."pos"()
+    rx1179_pos = $P10."pos"()
   # rx pass
-    rx1211_cur."!cursor_pass"(rx1211_pos, "infix:sym<>>")
-    rx1211_cur."!cursor_debug"("PASS  ", "infix:sym<>>", " at pos=", rx1211_pos)
-    .return (rx1211_cur)
-  rx1211_fail:
+    rx1179_cur."!cursor_pass"(rx1179_pos, "infix:sym<>>")
+    rx1179_cur."!cursor_debug"("PASS  ", "infix:sym<>>", " at pos=", rx1179_pos)
+    .return (rx1179_cur)
+  rx1179_restart:
 .annotate 'line', 447
-    (rx1211_rep, rx1211_pos, $I10, $P10) = rx1211_cur."!mark_fail"(0)
-    lt rx1211_pos, -1, rx1211_done
-    eq rx1211_pos, -1, rx1211_fail
+    rx1179_cur."!cursor_debug"("NEXT ", "infix:sym<>>")
+  rx1179_fail:
+    (rx1179_rep, rx1179_pos, $I10, $P10) = rx1179_cur."!mark_fail"(0)
+    lt rx1179_pos, -1, rx1179_done
+    eq rx1179_pos, -1, rx1179_fail
     jump $I10
-  rx1211_done:
-    rx1211_cur."!cursor_fail"()
-    rx1211_cur."!cursor_debug"("FAIL  ", "infix:sym<>>")
-    .return (rx1211_cur)
+  rx1179_done:
+    rx1179_cur."!cursor_fail"()
+    rx1179_cur."!cursor_debug"("FAIL  ", "infix:sym<>>")
+    .return (rx1179_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<>>"  :subid("305_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<>>"  :subid("305_1279529226.73787") :method
 .annotate 'line', 447
-    $P1213 = self."!PREFIX__!subrule"("O", ">")
-    new $P1214, "ResizablePMCArray"
-    push $P1214, $P1213
-    .return ($P1214)
+    $P1181 = self."!PREFIX__!subrule"("O", ">")
+    new $P1182, "ResizablePMCArray"
+    push $P1182, $P1181
+    .return ($P1182)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<eq>"  :subid("306_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<eq>"  :subid("306_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1218_tgt
-    .local int rx1218_pos
-    .local int rx1218_off
-    .local int rx1218_eos
-    .local int rx1218_rep
-    .local pmc rx1218_cur
-    (rx1218_cur, rx1218_pos, rx1218_tgt) = self."!cursor_start"()
-    rx1218_cur."!cursor_debug"("START ", "infix:sym<eq>")
-    .lex unicode:"$\x{a2}", rx1218_cur
+    .local string rx1186_tgt
+    .local int rx1186_pos
+    .local int rx1186_off
+    .local int rx1186_eos
+    .local int rx1186_rep
+    .local pmc rx1186_cur
+    (rx1186_cur, rx1186_pos, rx1186_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1186_cur
     .local pmc match
     .lex "$/", match
-    length rx1218_eos, rx1218_tgt
-    gt rx1218_pos, rx1218_eos, rx1218_done
-    set rx1218_off, 0
-    lt rx1218_pos, 2, rx1218_start
-    sub rx1218_off, rx1218_pos, 1
-    substr rx1218_tgt, rx1218_tgt, rx1218_off
-  rx1218_start:
+    length rx1186_eos, rx1186_tgt
+    gt rx1186_pos, rx1186_eos, rx1186_done
+    set rx1186_off, 0
+    lt rx1186_pos, 2, rx1186_start
+    sub rx1186_off, rx1186_pos, 1
+    substr rx1186_tgt, rx1186_tgt, rx1186_off
+  rx1186_start:
+    eq $I10, 1, rx1186_restart
+    rx1186_cur."!cursor_debug"("START ", "infix:sym<eq>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1222_done
-    goto rxscan1222_scan
-  rxscan1222_loop:
-    ($P10) = rx1218_cur."from"()
+    ne $I10, -1, rxscan1190_done
+    goto rxscan1190_scan
+  rxscan1190_loop:
+    ($P10) = rx1186_cur."from"()
     inc $P10
-    set rx1218_pos, $P10
-    ge rx1218_pos, rx1218_eos, rxscan1222_done
-  rxscan1222_scan:
-    set_addr $I10, rxscan1222_loop
-    rx1218_cur."!mark_push"(0, rx1218_pos, $I10)
-  rxscan1222_done:
+    set rx1186_pos, $P10
+    ge rx1186_pos, rx1186_eos, rxscan1190_done
+  rxscan1190_scan:
+    set_addr $I10, rxscan1190_loop
+    rx1186_cur."!mark_push"(0, rx1186_pos, $I10)
+  rxscan1190_done:
 .annotate 'line', 525
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1223_fail
-    rx1218_cur."!mark_push"(0, rx1218_pos, $I10)
+    set_addr $I10, rxcap_1191_fail
+    rx1186_cur."!mark_push"(0, rx1186_pos, $I10)
   # rx literal  "eq"
-    add $I11, rx1218_pos, 2
-    gt $I11, rx1218_eos, rx1218_fail
-    sub $I11, rx1218_pos, rx1218_off
-    substr $S10, rx1218_tgt, $I11, 2
-    ne $S10, "eq", rx1218_fail
-    add rx1218_pos, 2
-    set_addr $I10, rxcap_1223_fail
-    ($I12, $I11) = rx1218_cur."!mark_peek"($I10)
-    rx1218_cur."!cursor_pos"($I11)
-    ($P10) = rx1218_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1218_pos, "")
-    rx1218_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1186_pos, 2
+    gt $I11, rx1186_eos, rx1186_fail
+    sub $I11, rx1186_pos, rx1186_off
+    substr $S10, rx1186_tgt, $I11, 2
+    ne $S10, "eq", rx1186_fail
+    add rx1186_pos, 2
+    set_addr $I10, rxcap_1191_fail
+    ($I12, $I11) = rx1186_cur."!mark_peek"($I10)
+    rx1186_cur."!cursor_pos"($I11)
+    ($P10) = rx1186_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1186_pos, "")
+    rx1186_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1223_done
-  rxcap_1223_fail:
-    goto rx1218_fail
-  rxcap_1223_done:
+    goto rxcap_1191_done
+  rxcap_1191_fail:
+    goto rx1186_fail
+  rxcap_1191_done:
   # rx subrule "O" subtype=capture negate=
-    rx1218_cur."!cursor_pos"(rx1218_pos)
-    $P10 = rx1218_cur."O"("%relational, :pirop<iseq ISs>")
-    unless $P10, rx1218_fail
-    rx1218_cur."!mark_push"(0, -1, 0, $P10)
+    rx1186_cur."!cursor_pos"(rx1186_pos)
+    $P10 = rx1186_cur."O"("%relational, :pirop<iseq ISs>")
+    unless $P10, rx1186_fail
+    rx1186_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1218_pos = $P10."pos"()
+    rx1186_pos = $P10."pos"()
   # rx pass
-    rx1218_cur."!cursor_pass"(rx1218_pos, "infix:sym<eq>")
-    rx1218_cur."!cursor_debug"("PASS  ", "infix:sym<eq>", " at pos=", rx1218_pos)
-    .return (rx1218_cur)
-  rx1218_fail:
+    rx1186_cur."!cursor_pass"(rx1186_pos, "infix:sym<eq>")
+    rx1186_cur."!cursor_debug"("PASS  ", "infix:sym<eq>", " at pos=", rx1186_pos)
+    .return (rx1186_cur)
+  rx1186_restart:
 .annotate 'line', 447
-    (rx1218_rep, rx1218_pos, $I10, $P10) = rx1218_cur."!mark_fail"(0)
-    lt rx1218_pos, -1, rx1218_done
-    eq rx1218_pos, -1, rx1218_fail
+    rx1186_cur."!cursor_debug"("NEXT ", "infix:sym<eq>")
+  rx1186_fail:
+    (rx1186_rep, rx1186_pos, $I10, $P10) = rx1186_cur."!mark_fail"(0)
+    lt rx1186_pos, -1, rx1186_done
+    eq rx1186_pos, -1, rx1186_fail
     jump $I10
-  rx1218_done:
-    rx1218_cur."!cursor_fail"()
-    rx1218_cur."!cursor_debug"("FAIL  ", "infix:sym<eq>")
-    .return (rx1218_cur)
+  rx1186_done:
+    rx1186_cur."!cursor_fail"()
+    rx1186_cur."!cursor_debug"("FAIL  ", "infix:sym<eq>")
+    .return (rx1186_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<eq>"  :subid("307_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<eq>"  :subid("307_1279529226.73787") :method
 .annotate 'line', 447
-    $P1220 = self."!PREFIX__!subrule"("O", "eq")
-    new $P1221, "ResizablePMCArray"
-    push $P1221, $P1220
-    .return ($P1221)
+    $P1188 = self."!PREFIX__!subrule"("O", "eq")
+    new $P1189, "ResizablePMCArray"
+    push $P1189, $P1188
+    .return ($P1189)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<ne>"  :subid("308_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<ne>"  :subid("308_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1225_tgt
-    .local int rx1225_pos
-    .local int rx1225_off
-    .local int rx1225_eos
-    .local int rx1225_rep
-    .local pmc rx1225_cur
-    (rx1225_cur, rx1225_pos, rx1225_tgt) = self."!cursor_start"()
-    rx1225_cur."!cursor_debug"("START ", "infix:sym<ne>")
-    .lex unicode:"$\x{a2}", rx1225_cur
+    .local string rx1193_tgt
+    .local int rx1193_pos
+    .local int rx1193_off
+    .local int rx1193_eos
+    .local int rx1193_rep
+    .local pmc rx1193_cur
+    (rx1193_cur, rx1193_pos, rx1193_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1193_cur
     .local pmc match
     .lex "$/", match
-    length rx1225_eos, rx1225_tgt
-    gt rx1225_pos, rx1225_eos, rx1225_done
-    set rx1225_off, 0
-    lt rx1225_pos, 2, rx1225_start
-    sub rx1225_off, rx1225_pos, 1
-    substr rx1225_tgt, rx1225_tgt, rx1225_off
-  rx1225_start:
+    length rx1193_eos, rx1193_tgt
+    gt rx1193_pos, rx1193_eos, rx1193_done
+    set rx1193_off, 0
+    lt rx1193_pos, 2, rx1193_start
+    sub rx1193_off, rx1193_pos, 1
+    substr rx1193_tgt, rx1193_tgt, rx1193_off
+  rx1193_start:
+    eq $I10, 1, rx1193_restart
+    rx1193_cur."!cursor_debug"("START ", "infix:sym<ne>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1229_done
-    goto rxscan1229_scan
-  rxscan1229_loop:
-    ($P10) = rx1225_cur."from"()
+    ne $I10, -1, rxscan1197_done
+    goto rxscan1197_scan
+  rxscan1197_loop:
+    ($P10) = rx1193_cur."from"()
     inc $P10
-    set rx1225_pos, $P10
-    ge rx1225_pos, rx1225_eos, rxscan1229_done
-  rxscan1229_scan:
-    set_addr $I10, rxscan1229_loop
-    rx1225_cur."!mark_push"(0, rx1225_pos, $I10)
-  rxscan1229_done:
+    set rx1193_pos, $P10
+    ge rx1193_pos, rx1193_eos, rxscan1197_done
+  rxscan1197_scan:
+    set_addr $I10, rxscan1197_loop
+    rx1193_cur."!mark_push"(0, rx1193_pos, $I10)
+  rxscan1197_done:
 .annotate 'line', 526
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1230_fail
-    rx1225_cur."!mark_push"(0, rx1225_pos, $I10)
+    set_addr $I10, rxcap_1198_fail
+    rx1193_cur."!mark_push"(0, rx1193_pos, $I10)
   # rx literal  "ne"
-    add $I11, rx1225_pos, 2
-    gt $I11, rx1225_eos, rx1225_fail
-    sub $I11, rx1225_pos, rx1225_off
-    substr $S10, rx1225_tgt, $I11, 2
-    ne $S10, "ne", rx1225_fail
-    add rx1225_pos, 2
-    set_addr $I10, rxcap_1230_fail
-    ($I12, $I11) = rx1225_cur."!mark_peek"($I10)
-    rx1225_cur."!cursor_pos"($I11)
-    ($P10) = rx1225_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1225_pos, "")
-    rx1225_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1193_pos, 2
+    gt $I11, rx1193_eos, rx1193_fail
+    sub $I11, rx1193_pos, rx1193_off
+    substr $S10, rx1193_tgt, $I11, 2
+    ne $S10, "ne", rx1193_fail
+    add rx1193_pos, 2
+    set_addr $I10, rxcap_1198_fail
+    ($I12, $I11) = rx1193_cur."!mark_peek"($I10)
+    rx1193_cur."!cursor_pos"($I11)
+    ($P10) = rx1193_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1193_pos, "")
+    rx1193_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1230_done
-  rxcap_1230_fail:
-    goto rx1225_fail
-  rxcap_1230_done:
+    goto rxcap_1198_done
+  rxcap_1198_fail:
+    goto rx1193_fail
+  rxcap_1198_done:
   # rx subrule "O" subtype=capture negate=
-    rx1225_cur."!cursor_pos"(rx1225_pos)
-    $P10 = rx1225_cur."O"("%relational, :pirop<isne ISs>")
-    unless $P10, rx1225_fail
-    rx1225_cur."!mark_push"(0, -1, 0, $P10)
+    rx1193_cur."!cursor_pos"(rx1193_pos)
+    $P10 = rx1193_cur."O"("%relational, :pirop<isne ISs>")
+    unless $P10, rx1193_fail
+    rx1193_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1225_pos = $P10."pos"()
+    rx1193_pos = $P10."pos"()
   # rx pass
-    rx1225_cur."!cursor_pass"(rx1225_pos, "infix:sym<ne>")
-    rx1225_cur."!cursor_debug"("PASS  ", "infix:sym<ne>", " at pos=", rx1225_pos)
-    .return (rx1225_cur)
-  rx1225_fail:
+    rx1193_cur."!cursor_pass"(rx1193_pos, "infix:sym<ne>")
+    rx1193_cur."!cursor_debug"("PASS  ", "infix:sym<ne>", " at pos=", rx1193_pos)
+    .return (rx1193_cur)
+  rx1193_restart:
 .annotate 'line', 447
-    (rx1225_rep, rx1225_pos, $I10, $P10) = rx1225_cur."!mark_fail"(0)
-    lt rx1225_pos, -1, rx1225_done
-    eq rx1225_pos, -1, rx1225_fail
+    rx1193_cur."!cursor_debug"("NEXT ", "infix:sym<ne>")
+  rx1193_fail:
+    (rx1193_rep, rx1193_pos, $I10, $P10) = rx1193_cur."!mark_fail"(0)
+    lt rx1193_pos, -1, rx1193_done
+    eq rx1193_pos, -1, rx1193_fail
     jump $I10
-  rx1225_done:
-    rx1225_cur."!cursor_fail"()
-    rx1225_cur."!cursor_debug"("FAIL  ", "infix:sym<ne>")
-    .return (rx1225_cur)
+  rx1193_done:
+    rx1193_cur."!cursor_fail"()
+    rx1193_cur."!cursor_debug"("FAIL  ", "infix:sym<ne>")
+    .return (rx1193_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<ne>"  :subid("309_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<ne>"  :subid("309_1279529226.73787") :method
 .annotate 'line', 447
-    $P1227 = self."!PREFIX__!subrule"("O", "ne")
-    new $P1228, "ResizablePMCArray"
-    push $P1228, $P1227
-    .return ($P1228)
+    $P1195 = self."!PREFIX__!subrule"("O", "ne")
+    new $P1196, "ResizablePMCArray"
+    push $P1196, $P1195
+    .return ($P1196)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<le>"  :subid("310_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<le>"  :subid("310_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1232_tgt
-    .local int rx1232_pos
-    .local int rx1232_off
-    .local int rx1232_eos
-    .local int rx1232_rep
-    .local pmc rx1232_cur
-    (rx1232_cur, rx1232_pos, rx1232_tgt) = self."!cursor_start"()
-    rx1232_cur."!cursor_debug"("START ", "infix:sym<le>")
-    .lex unicode:"$\x{a2}", rx1232_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1232_eos, rx1232_tgt
-    gt rx1232_pos, rx1232_eos, rx1232_done
-    set rx1232_off, 0
-    lt rx1232_pos, 2, rx1232_start
-    sub rx1232_off, rx1232_pos, 1
-    substr rx1232_tgt, rx1232_tgt, rx1232_off
-  rx1232_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1236_done
-    goto rxscan1236_scan
-  rxscan1236_loop:
-    ($P10) = rx1232_cur."from"()
-    inc $P10
-    set rx1232_pos, $P10
-    ge rx1232_pos, rx1232_eos, rxscan1236_done
-  rxscan1236_scan:
-    set_addr $I10, rxscan1236_loop
-    rx1232_cur."!mark_push"(0, rx1232_pos, $I10)
-  rxscan1236_done:
+    .local string rx1200_tgt
+    .local int rx1200_pos
+    .local int rx1200_off
+    .local int rx1200_eos
+    .local int rx1200_rep
+    .local pmc rx1200_cur
+    (rx1200_cur, rx1200_pos, rx1200_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1200_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1200_eos, rx1200_tgt
+    gt rx1200_pos, rx1200_eos, rx1200_done
+    set rx1200_off, 0
+    lt rx1200_pos, 2, rx1200_start
+    sub rx1200_off, rx1200_pos, 1
+    substr rx1200_tgt, rx1200_tgt, rx1200_off
+  rx1200_start:
+    eq $I10, 1, rx1200_restart
+    rx1200_cur."!cursor_debug"("START ", "infix:sym<le>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1204_done
+    goto rxscan1204_scan
+  rxscan1204_loop:
+    ($P10) = rx1200_cur."from"()
+    inc $P10
+    set rx1200_pos, $P10
+    ge rx1200_pos, rx1200_eos, rxscan1204_done
+  rxscan1204_scan:
+    set_addr $I10, rxscan1204_loop
+    rx1200_cur."!mark_push"(0, rx1200_pos, $I10)
+  rxscan1204_done:
 .annotate 'line', 527
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1237_fail
-    rx1232_cur."!mark_push"(0, rx1232_pos, $I10)
+    set_addr $I10, rxcap_1205_fail
+    rx1200_cur."!mark_push"(0, rx1200_pos, $I10)
   # rx literal  "le"
-    add $I11, rx1232_pos, 2
-    gt $I11, rx1232_eos, rx1232_fail
-    sub $I11, rx1232_pos, rx1232_off
-    substr $S10, rx1232_tgt, $I11, 2
-    ne $S10, "le", rx1232_fail
-    add rx1232_pos, 2
-    set_addr $I10, rxcap_1237_fail
-    ($I12, $I11) = rx1232_cur."!mark_peek"($I10)
-    rx1232_cur."!cursor_pos"($I11)
-    ($P10) = rx1232_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1232_pos, "")
-    rx1232_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1200_pos, 2
+    gt $I11, rx1200_eos, rx1200_fail
+    sub $I11, rx1200_pos, rx1200_off
+    substr $S10, rx1200_tgt, $I11, 2
+    ne $S10, "le", rx1200_fail
+    add rx1200_pos, 2
+    set_addr $I10, rxcap_1205_fail
+    ($I12, $I11) = rx1200_cur."!mark_peek"($I10)
+    rx1200_cur."!cursor_pos"($I11)
+    ($P10) = rx1200_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1200_pos, "")
+    rx1200_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1237_done
-  rxcap_1237_fail:
-    goto rx1232_fail
-  rxcap_1237_done:
+    goto rxcap_1205_done
+  rxcap_1205_fail:
+    goto rx1200_fail
+  rxcap_1205_done:
   # rx subrule "O" subtype=capture negate=
-    rx1232_cur."!cursor_pos"(rx1232_pos)
-    $P10 = rx1232_cur."O"("%relational, :pirop<isle ISs>")
-    unless $P10, rx1232_fail
-    rx1232_cur."!mark_push"(0, -1, 0, $P10)
+    rx1200_cur."!cursor_pos"(rx1200_pos)
+    $P10 = rx1200_cur."O"("%relational, :pirop<isle ISs>")
+    unless $P10, rx1200_fail
+    rx1200_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1232_pos = $P10."pos"()
+    rx1200_pos = $P10."pos"()
   # rx pass
-    rx1232_cur."!cursor_pass"(rx1232_pos, "infix:sym<le>")
-    rx1232_cur."!cursor_debug"("PASS  ", "infix:sym<le>", " at pos=", rx1232_pos)
-    .return (rx1232_cur)
-  rx1232_fail:
+    rx1200_cur."!cursor_pass"(rx1200_pos, "infix:sym<le>")
+    rx1200_cur."!cursor_debug"("PASS  ", "infix:sym<le>", " at pos=", rx1200_pos)
+    .return (rx1200_cur)
+  rx1200_restart:
 .annotate 'line', 447
-    (rx1232_rep, rx1232_pos, $I10, $P10) = rx1232_cur."!mark_fail"(0)
-    lt rx1232_pos, -1, rx1232_done
-    eq rx1232_pos, -1, rx1232_fail
+    rx1200_cur."!cursor_debug"("NEXT ", "infix:sym<le>")
+  rx1200_fail:
+    (rx1200_rep, rx1200_pos, $I10, $P10) = rx1200_cur."!mark_fail"(0)
+    lt rx1200_pos, -1, rx1200_done
+    eq rx1200_pos, -1, rx1200_fail
     jump $I10
-  rx1232_done:
-    rx1232_cur."!cursor_fail"()
-    rx1232_cur."!cursor_debug"("FAIL  ", "infix:sym<le>")
-    .return (rx1232_cur)
+  rx1200_done:
+    rx1200_cur."!cursor_fail"()
+    rx1200_cur."!cursor_debug"("FAIL  ", "infix:sym<le>")
+    .return (rx1200_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<le>"  :subid("311_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<le>"  :subid("311_1279529226.73787") :method
 .annotate 'line', 447
-    $P1234 = self."!PREFIX__!subrule"("O", "le")
-    new $P1235, "ResizablePMCArray"
-    push $P1235, $P1234
-    .return ($P1235)
+    $P1202 = self."!PREFIX__!subrule"("O", "le")
+    new $P1203, "ResizablePMCArray"
+    push $P1203, $P1202
+    .return ($P1203)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<ge>"  :subid("312_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<ge>"  :subid("312_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1239_tgt
-    .local int rx1239_pos
-    .local int rx1239_off
-    .local int rx1239_eos
-    .local int rx1239_rep
-    .local pmc rx1239_cur
-    (rx1239_cur, rx1239_pos, rx1239_tgt) = self."!cursor_start"()
-    rx1239_cur."!cursor_debug"("START ", "infix:sym<ge>")
-    .lex unicode:"$\x{a2}", rx1239_cur
+    .local string rx1207_tgt
+    .local int rx1207_pos
+    .local int rx1207_off
+    .local int rx1207_eos
+    .local int rx1207_rep
+    .local pmc rx1207_cur
+    (rx1207_cur, rx1207_pos, rx1207_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1207_cur
     .local pmc match
     .lex "$/", match
-    length rx1239_eos, rx1239_tgt
-    gt rx1239_pos, rx1239_eos, rx1239_done
-    set rx1239_off, 0
-    lt rx1239_pos, 2, rx1239_start
-    sub rx1239_off, rx1239_pos, 1
-    substr rx1239_tgt, rx1239_tgt, rx1239_off
-  rx1239_start:
+    length rx1207_eos, rx1207_tgt
+    gt rx1207_pos, rx1207_eos, rx1207_done
+    set rx1207_off, 0
+    lt rx1207_pos, 2, rx1207_start
+    sub rx1207_off, rx1207_pos, 1
+    substr rx1207_tgt, rx1207_tgt, rx1207_off
+  rx1207_start:
+    eq $I10, 1, rx1207_restart
+    rx1207_cur."!cursor_debug"("START ", "infix:sym<ge>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1243_done
-    goto rxscan1243_scan
-  rxscan1243_loop:
-    ($P10) = rx1239_cur."from"()
+    ne $I10, -1, rxscan1211_done
+    goto rxscan1211_scan
+  rxscan1211_loop:
+    ($P10) = rx1207_cur."from"()
     inc $P10
-    set rx1239_pos, $P10
-    ge rx1239_pos, rx1239_eos, rxscan1243_done
-  rxscan1243_scan:
-    set_addr $I10, rxscan1243_loop
-    rx1239_cur."!mark_push"(0, rx1239_pos, $I10)
-  rxscan1243_done:
+    set rx1207_pos, $P10
+    ge rx1207_pos, rx1207_eos, rxscan1211_done
+  rxscan1211_scan:
+    set_addr $I10, rxscan1211_loop
+    rx1207_cur."!mark_push"(0, rx1207_pos, $I10)
+  rxscan1211_done:
 .annotate 'line', 528
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1244_fail
-    rx1239_cur."!mark_push"(0, rx1239_pos, $I10)
+    set_addr $I10, rxcap_1212_fail
+    rx1207_cur."!mark_push"(0, rx1207_pos, $I10)
   # rx literal  "ge"
-    add $I11, rx1239_pos, 2
-    gt $I11, rx1239_eos, rx1239_fail
-    sub $I11, rx1239_pos, rx1239_off
-    substr $S10, rx1239_tgt, $I11, 2
-    ne $S10, "ge", rx1239_fail
-    add rx1239_pos, 2
-    set_addr $I10, rxcap_1244_fail
-    ($I12, $I11) = rx1239_cur."!mark_peek"($I10)
-    rx1239_cur."!cursor_pos"($I11)
-    ($P10) = rx1239_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1239_pos, "")
-    rx1239_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1207_pos, 2
+    gt $I11, rx1207_eos, rx1207_fail
+    sub $I11, rx1207_pos, rx1207_off
+    substr $S10, rx1207_tgt, $I11, 2
+    ne $S10, "ge", rx1207_fail
+    add rx1207_pos, 2
+    set_addr $I10, rxcap_1212_fail
+    ($I12, $I11) = rx1207_cur."!mark_peek"($I10)
+    rx1207_cur."!cursor_pos"($I11)
+    ($P10) = rx1207_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1207_pos, "")
+    rx1207_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1244_done
-  rxcap_1244_fail:
-    goto rx1239_fail
-  rxcap_1244_done:
+    goto rxcap_1212_done
+  rxcap_1212_fail:
+    goto rx1207_fail
+  rxcap_1212_done:
   # rx subrule "O" subtype=capture negate=
-    rx1239_cur."!cursor_pos"(rx1239_pos)
-    $P10 = rx1239_cur."O"("%relational, :pirop<isge ISs>")
-    unless $P10, rx1239_fail
-    rx1239_cur."!mark_push"(0, -1, 0, $P10)
+    rx1207_cur."!cursor_pos"(rx1207_pos)
+    $P10 = rx1207_cur."O"("%relational, :pirop<isge ISs>")
+    unless $P10, rx1207_fail
+    rx1207_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1239_pos = $P10."pos"()
+    rx1207_pos = $P10."pos"()
   # rx pass
-    rx1239_cur."!cursor_pass"(rx1239_pos, "infix:sym<ge>")
-    rx1239_cur."!cursor_debug"("PASS  ", "infix:sym<ge>", " at pos=", rx1239_pos)
-    .return (rx1239_cur)
-  rx1239_fail:
+    rx1207_cur."!cursor_pass"(rx1207_pos, "infix:sym<ge>")
+    rx1207_cur."!cursor_debug"("PASS  ", "infix:sym<ge>", " at pos=", rx1207_pos)
+    .return (rx1207_cur)
+  rx1207_restart:
 .annotate 'line', 447
-    (rx1239_rep, rx1239_pos, $I10, $P10) = rx1239_cur."!mark_fail"(0)
-    lt rx1239_pos, -1, rx1239_done
-    eq rx1239_pos, -1, rx1239_fail
+    rx1207_cur."!cursor_debug"("NEXT ", "infix:sym<ge>")
+  rx1207_fail:
+    (rx1207_rep, rx1207_pos, $I10, $P10) = rx1207_cur."!mark_fail"(0)
+    lt rx1207_pos, -1, rx1207_done
+    eq rx1207_pos, -1, rx1207_fail
     jump $I10
-  rx1239_done:
-    rx1239_cur."!cursor_fail"()
-    rx1239_cur."!cursor_debug"("FAIL  ", "infix:sym<ge>")
-    .return (rx1239_cur)
+  rx1207_done:
+    rx1207_cur."!cursor_fail"()
+    rx1207_cur."!cursor_debug"("FAIL  ", "infix:sym<ge>")
+    .return (rx1207_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<ge>"  :subid("313_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<ge>"  :subid("313_1279529226.73787") :method
 .annotate 'line', 447
-    $P1241 = self."!PREFIX__!subrule"("O", "ge")
-    new $P1242, "ResizablePMCArray"
-    push $P1242, $P1241
-    .return ($P1242)
+    $P1209 = self."!PREFIX__!subrule"("O", "ge")
+    new $P1210, "ResizablePMCArray"
+    push $P1210, $P1209
+    .return ($P1210)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<lt>"  :subid("314_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<lt>"  :subid("314_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1246_tgt
-    .local int rx1246_pos
-    .local int rx1246_off
-    .local int rx1246_eos
-    .local int rx1246_rep
-    .local pmc rx1246_cur
-    (rx1246_cur, rx1246_pos, rx1246_tgt) = self."!cursor_start"()
-    rx1246_cur."!cursor_debug"("START ", "infix:sym<lt>")
-    .lex unicode:"$\x{a2}", rx1246_cur
+    .local string rx1214_tgt
+    .local int rx1214_pos
+    .local int rx1214_off
+    .local int rx1214_eos
+    .local int rx1214_rep
+    .local pmc rx1214_cur
+    (rx1214_cur, rx1214_pos, rx1214_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1214_cur
     .local pmc match
     .lex "$/", match
-    length rx1246_eos, rx1246_tgt
-    gt rx1246_pos, rx1246_eos, rx1246_done
-    set rx1246_off, 0
-    lt rx1246_pos, 2, rx1246_start
-    sub rx1246_off, rx1246_pos, 1
-    substr rx1246_tgt, rx1246_tgt, rx1246_off
-  rx1246_start:
+    length rx1214_eos, rx1214_tgt
+    gt rx1214_pos, rx1214_eos, rx1214_done
+    set rx1214_off, 0
+    lt rx1214_pos, 2, rx1214_start
+    sub rx1214_off, rx1214_pos, 1
+    substr rx1214_tgt, rx1214_tgt, rx1214_off
+  rx1214_start:
+    eq $I10, 1, rx1214_restart
+    rx1214_cur."!cursor_debug"("START ", "infix:sym<lt>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1250_done
-    goto rxscan1250_scan
-  rxscan1250_loop:
-    ($P10) = rx1246_cur."from"()
+    ne $I10, -1, rxscan1218_done
+    goto rxscan1218_scan
+  rxscan1218_loop:
+    ($P10) = rx1214_cur."from"()
     inc $P10
-    set rx1246_pos, $P10
-    ge rx1246_pos, rx1246_eos, rxscan1250_done
-  rxscan1250_scan:
-    set_addr $I10, rxscan1250_loop
-    rx1246_cur."!mark_push"(0, rx1246_pos, $I10)
-  rxscan1250_done:
+    set rx1214_pos, $P10
+    ge rx1214_pos, rx1214_eos, rxscan1218_done
+  rxscan1218_scan:
+    set_addr $I10, rxscan1218_loop
+    rx1214_cur."!mark_push"(0, rx1214_pos, $I10)
+  rxscan1218_done:
 .annotate 'line', 529
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1251_fail
-    rx1246_cur."!mark_push"(0, rx1246_pos, $I10)
+    set_addr $I10, rxcap_1219_fail
+    rx1214_cur."!mark_push"(0, rx1214_pos, $I10)
   # rx literal  "lt"
-    add $I11, rx1246_pos, 2
-    gt $I11, rx1246_eos, rx1246_fail
-    sub $I11, rx1246_pos, rx1246_off
-    substr $S10, rx1246_tgt, $I11, 2
-    ne $S10, "lt", rx1246_fail
-    add rx1246_pos, 2
-    set_addr $I10, rxcap_1251_fail
-    ($I12, $I11) = rx1246_cur."!mark_peek"($I10)
-    rx1246_cur."!cursor_pos"($I11)
-    ($P10) = rx1246_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1246_pos, "")
-    rx1246_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1214_pos, 2
+    gt $I11, rx1214_eos, rx1214_fail
+    sub $I11, rx1214_pos, rx1214_off
+    substr $S10, rx1214_tgt, $I11, 2
+    ne $S10, "lt", rx1214_fail
+    add rx1214_pos, 2
+    set_addr $I10, rxcap_1219_fail
+    ($I12, $I11) = rx1214_cur."!mark_peek"($I10)
+    rx1214_cur."!cursor_pos"($I11)
+    ($P10) = rx1214_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1214_pos, "")
+    rx1214_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1251_done
-  rxcap_1251_fail:
-    goto rx1246_fail
-  rxcap_1251_done:
+    goto rxcap_1219_done
+  rxcap_1219_fail:
+    goto rx1214_fail
+  rxcap_1219_done:
   # rx subrule "O" subtype=capture negate=
-    rx1246_cur."!cursor_pos"(rx1246_pos)
-    $P10 = rx1246_cur."O"("%relational, :pirop<islt ISs>")
-    unless $P10, rx1246_fail
-    rx1246_cur."!mark_push"(0, -1, 0, $P10)
+    rx1214_cur."!cursor_pos"(rx1214_pos)
+    $P10 = rx1214_cur."O"("%relational, :pirop<islt ISs>")
+    unless $P10, rx1214_fail
+    rx1214_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1246_pos = $P10."pos"()
+    rx1214_pos = $P10."pos"()
   # rx pass
-    rx1246_cur."!cursor_pass"(rx1246_pos, "infix:sym<lt>")
-    rx1246_cur."!cursor_debug"("PASS  ", "infix:sym<lt>", " at pos=", rx1246_pos)
-    .return (rx1246_cur)
-  rx1246_fail:
+    rx1214_cur."!cursor_pass"(rx1214_pos, "infix:sym<lt>")
+    rx1214_cur."!cursor_debug"("PASS  ", "infix:sym<lt>", " at pos=", rx1214_pos)
+    .return (rx1214_cur)
+  rx1214_restart:
 .annotate 'line', 447
-    (rx1246_rep, rx1246_pos, $I10, $P10) = rx1246_cur."!mark_fail"(0)
-    lt rx1246_pos, -1, rx1246_done
-    eq rx1246_pos, -1, rx1246_fail
+    rx1214_cur."!cursor_debug"("NEXT ", "infix:sym<lt>")
+  rx1214_fail:
+    (rx1214_rep, rx1214_pos, $I10, $P10) = rx1214_cur."!mark_fail"(0)
+    lt rx1214_pos, -1, rx1214_done
+    eq rx1214_pos, -1, rx1214_fail
     jump $I10
-  rx1246_done:
-    rx1246_cur."!cursor_fail"()
-    rx1246_cur."!cursor_debug"("FAIL  ", "infix:sym<lt>")
-    .return (rx1246_cur)
+  rx1214_done:
+    rx1214_cur."!cursor_fail"()
+    rx1214_cur."!cursor_debug"("FAIL  ", "infix:sym<lt>")
+    .return (rx1214_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<lt>"  :subid("315_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<lt>"  :subid("315_1279529226.73787") :method
 .annotate 'line', 447
-    $P1248 = self."!PREFIX__!subrule"("O", "lt")
-    new $P1249, "ResizablePMCArray"
-    push $P1249, $P1248
-    .return ($P1249)
+    $P1216 = self."!PREFIX__!subrule"("O", "lt")
+    new $P1217, "ResizablePMCArray"
+    push $P1217, $P1216
+    .return ($P1217)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<gt>"  :subid("316_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<gt>"  :subid("316_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1253_tgt
-    .local int rx1253_pos
-    .local int rx1253_off
-    .local int rx1253_eos
-    .local int rx1253_rep
-    .local pmc rx1253_cur
-    (rx1253_cur, rx1253_pos, rx1253_tgt) = self."!cursor_start"()
-    rx1253_cur."!cursor_debug"("START ", "infix:sym<gt>")
-    .lex unicode:"$\x{a2}", rx1253_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1253_eos, rx1253_tgt
-    gt rx1253_pos, rx1253_eos, rx1253_done
-    set rx1253_off, 0
-    lt rx1253_pos, 2, rx1253_start
-    sub rx1253_off, rx1253_pos, 1
-    substr rx1253_tgt, rx1253_tgt, rx1253_off
-  rx1253_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1257_done
-    goto rxscan1257_scan
-  rxscan1257_loop:
-    ($P10) = rx1253_cur."from"()
-    inc $P10
-    set rx1253_pos, $P10
-    ge rx1253_pos, rx1253_eos, rxscan1257_done
-  rxscan1257_scan:
-    set_addr $I10, rxscan1257_loop
-    rx1253_cur."!mark_push"(0, rx1253_pos, $I10)
-  rxscan1257_done:
+    .local string rx1221_tgt
+    .local int rx1221_pos
+    .local int rx1221_off
+    .local int rx1221_eos
+    .local int rx1221_rep
+    .local pmc rx1221_cur
+    (rx1221_cur, rx1221_pos, rx1221_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1221_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1221_eos, rx1221_tgt
+    gt rx1221_pos, rx1221_eos, rx1221_done
+    set rx1221_off, 0
+    lt rx1221_pos, 2, rx1221_start
+    sub rx1221_off, rx1221_pos, 1
+    substr rx1221_tgt, rx1221_tgt, rx1221_off
+  rx1221_start:
+    eq $I10, 1, rx1221_restart
+    rx1221_cur."!cursor_debug"("START ", "infix:sym<gt>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1225_done
+    goto rxscan1225_scan
+  rxscan1225_loop:
+    ($P10) = rx1221_cur."from"()
+    inc $P10
+    set rx1221_pos, $P10
+    ge rx1221_pos, rx1221_eos, rxscan1225_done
+  rxscan1225_scan:
+    set_addr $I10, rxscan1225_loop
+    rx1221_cur."!mark_push"(0, rx1221_pos, $I10)
+  rxscan1225_done:
 .annotate 'line', 530
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1258_fail
-    rx1253_cur."!mark_push"(0, rx1253_pos, $I10)
+    set_addr $I10, rxcap_1226_fail
+    rx1221_cur."!mark_push"(0, rx1221_pos, $I10)
   # rx literal  "gt"
-    add $I11, rx1253_pos, 2
-    gt $I11, rx1253_eos, rx1253_fail
-    sub $I11, rx1253_pos, rx1253_off
-    substr $S10, rx1253_tgt, $I11, 2
-    ne $S10, "gt", rx1253_fail
-    add rx1253_pos, 2
-    set_addr $I10, rxcap_1258_fail
-    ($I12, $I11) = rx1253_cur."!mark_peek"($I10)
-    rx1253_cur."!cursor_pos"($I11)
-    ($P10) = rx1253_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1253_pos, "")
-    rx1253_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1221_pos, 2
+    gt $I11, rx1221_eos, rx1221_fail
+    sub $I11, rx1221_pos, rx1221_off
+    substr $S10, rx1221_tgt, $I11, 2
+    ne $S10, "gt", rx1221_fail
+    add rx1221_pos, 2
+    set_addr $I10, rxcap_1226_fail
+    ($I12, $I11) = rx1221_cur."!mark_peek"($I10)
+    rx1221_cur."!cursor_pos"($I11)
+    ($P10) = rx1221_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1221_pos, "")
+    rx1221_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1258_done
-  rxcap_1258_fail:
-    goto rx1253_fail
-  rxcap_1258_done:
+    goto rxcap_1226_done
+  rxcap_1226_fail:
+    goto rx1221_fail
+  rxcap_1226_done:
   # rx subrule "O" subtype=capture negate=
-    rx1253_cur."!cursor_pos"(rx1253_pos)
-    $P10 = rx1253_cur."O"("%relational, :pirop<isgt ISs>")
-    unless $P10, rx1253_fail
-    rx1253_cur."!mark_push"(0, -1, 0, $P10)
+    rx1221_cur."!cursor_pos"(rx1221_pos)
+    $P10 = rx1221_cur."O"("%relational, :pirop<isgt ISs>")
+    unless $P10, rx1221_fail
+    rx1221_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1253_pos = $P10."pos"()
+    rx1221_pos = $P10."pos"()
   # rx pass
-    rx1253_cur."!cursor_pass"(rx1253_pos, "infix:sym<gt>")
-    rx1253_cur."!cursor_debug"("PASS  ", "infix:sym<gt>", " at pos=", rx1253_pos)
-    .return (rx1253_cur)
-  rx1253_fail:
+    rx1221_cur."!cursor_pass"(rx1221_pos, "infix:sym<gt>")
+    rx1221_cur."!cursor_debug"("PASS  ", "infix:sym<gt>", " at pos=", rx1221_pos)
+    .return (rx1221_cur)
+  rx1221_restart:
 .annotate 'line', 447
-    (rx1253_rep, rx1253_pos, $I10, $P10) = rx1253_cur."!mark_fail"(0)
-    lt rx1253_pos, -1, rx1253_done
-    eq rx1253_pos, -1, rx1253_fail
+    rx1221_cur."!cursor_debug"("NEXT ", "infix:sym<gt>")
+  rx1221_fail:
+    (rx1221_rep, rx1221_pos, $I10, $P10) = rx1221_cur."!mark_fail"(0)
+    lt rx1221_pos, -1, rx1221_done
+    eq rx1221_pos, -1, rx1221_fail
     jump $I10
-  rx1253_done:
-    rx1253_cur."!cursor_fail"()
-    rx1253_cur."!cursor_debug"("FAIL  ", "infix:sym<gt>")
-    .return (rx1253_cur)
+  rx1221_done:
+    rx1221_cur."!cursor_fail"()
+    rx1221_cur."!cursor_debug"("FAIL  ", "infix:sym<gt>")
+    .return (rx1221_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<gt>"  :subid("317_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<gt>"  :subid("317_1279529226.73787") :method
 .annotate 'line', 447
-    $P1255 = self."!PREFIX__!subrule"("O", "gt")
-    new $P1256, "ResizablePMCArray"
-    push $P1256, $P1255
-    .return ($P1256)
+    $P1223 = self."!PREFIX__!subrule"("O", "gt")
+    new $P1224, "ResizablePMCArray"
+    push $P1224, $P1223
+    .return ($P1224)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<=:=>"  :subid("318_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<=:=>"  :subid("318_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1260_tgt
-    .local int rx1260_pos
-    .local int rx1260_off
-    .local int rx1260_eos
-    .local int rx1260_rep
-    .local pmc rx1260_cur
-    (rx1260_cur, rx1260_pos, rx1260_tgt) = self."!cursor_start"()
-    rx1260_cur."!cursor_debug"("START ", "infix:sym<=:=>")
-    .lex unicode:"$\x{a2}", rx1260_cur
+    .local string rx1228_tgt
+    .local int rx1228_pos
+    .local int rx1228_off
+    .local int rx1228_eos
+    .local int rx1228_rep
+    .local pmc rx1228_cur
+    (rx1228_cur, rx1228_pos, rx1228_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1228_cur
     .local pmc match
     .lex "$/", match
-    length rx1260_eos, rx1260_tgt
-    gt rx1260_pos, rx1260_eos, rx1260_done
-    set rx1260_off, 0
-    lt rx1260_pos, 2, rx1260_start
-    sub rx1260_off, rx1260_pos, 1
-    substr rx1260_tgt, rx1260_tgt, rx1260_off
-  rx1260_start:
+    length rx1228_eos, rx1228_tgt
+    gt rx1228_pos, rx1228_eos, rx1228_done
+    set rx1228_off, 0
+    lt rx1228_pos, 2, rx1228_start
+    sub rx1228_off, rx1228_pos, 1
+    substr rx1228_tgt, rx1228_tgt, rx1228_off
+  rx1228_start:
+    eq $I10, 1, rx1228_restart
+    rx1228_cur."!cursor_debug"("START ", "infix:sym<=:=>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1264_done
-    goto rxscan1264_scan
-  rxscan1264_loop:
-    ($P10) = rx1260_cur."from"()
+    ne $I10, -1, rxscan1232_done
+    goto rxscan1232_scan
+  rxscan1232_loop:
+    ($P10) = rx1228_cur."from"()
     inc $P10
-    set rx1260_pos, $P10
-    ge rx1260_pos, rx1260_eos, rxscan1264_done
-  rxscan1264_scan:
-    set_addr $I10, rxscan1264_loop
-    rx1260_cur."!mark_push"(0, rx1260_pos, $I10)
-  rxscan1264_done:
+    set rx1228_pos, $P10
+    ge rx1228_pos, rx1228_eos, rxscan1232_done
+  rxscan1232_scan:
+    set_addr $I10, rxscan1232_loop
+    rx1228_cur."!mark_push"(0, rx1228_pos, $I10)
+  rxscan1232_done:
 .annotate 'line', 531
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1265_fail
-    rx1260_cur."!mark_push"(0, rx1260_pos, $I10)
+    set_addr $I10, rxcap_1233_fail
+    rx1228_cur."!mark_push"(0, rx1228_pos, $I10)
   # rx literal  "=:="
-    add $I11, rx1260_pos, 3
-    gt $I11, rx1260_eos, rx1260_fail
-    sub $I11, rx1260_pos, rx1260_off
-    substr $S10, rx1260_tgt, $I11, 3
-    ne $S10, "=:=", rx1260_fail
-    add rx1260_pos, 3
-    set_addr $I10, rxcap_1265_fail
-    ($I12, $I11) = rx1260_cur."!mark_peek"($I10)
-    rx1260_cur."!cursor_pos"($I11)
-    ($P10) = rx1260_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1260_pos, "")
-    rx1260_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1228_pos, 3
+    gt $I11, rx1228_eos, rx1228_fail
+    sub $I11, rx1228_pos, rx1228_off
+    substr $S10, rx1228_tgt, $I11, 3
+    ne $S10, "=:=", rx1228_fail
+    add rx1228_pos, 3
+    set_addr $I10, rxcap_1233_fail
+    ($I12, $I11) = rx1228_cur."!mark_peek"($I10)
+    rx1228_cur."!cursor_pos"($I11)
+    ($P10) = rx1228_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1228_pos, "")
+    rx1228_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1265_done
-  rxcap_1265_fail:
-    goto rx1260_fail
-  rxcap_1265_done:
+    goto rxcap_1233_done
+  rxcap_1233_fail:
+    goto rx1228_fail
+  rxcap_1233_done:
   # rx subrule "O" subtype=capture negate=
-    rx1260_cur."!cursor_pos"(rx1260_pos)
-    $P10 = rx1260_cur."O"("%relational, :pirop<issame>")
-    unless $P10, rx1260_fail
-    rx1260_cur."!mark_push"(0, -1, 0, $P10)
+    rx1228_cur."!cursor_pos"(rx1228_pos)
+    $P10 = rx1228_cur."O"("%relational, :pirop<issame>")
+    unless $P10, rx1228_fail
+    rx1228_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1260_pos = $P10."pos"()
+    rx1228_pos = $P10."pos"()
   # rx pass
-    rx1260_cur."!cursor_pass"(rx1260_pos, "infix:sym<=:=>")
-    rx1260_cur."!cursor_debug"("PASS  ", "infix:sym<=:=>", " at pos=", rx1260_pos)
-    .return (rx1260_cur)
-  rx1260_fail:
+    rx1228_cur."!cursor_pass"(rx1228_pos, "infix:sym<=:=>")
+    rx1228_cur."!cursor_debug"("PASS  ", "infix:sym<=:=>", " at pos=", rx1228_pos)
+    .return (rx1228_cur)
+  rx1228_restart:
 .annotate 'line', 447
-    (rx1260_rep, rx1260_pos, $I10, $P10) = rx1260_cur."!mark_fail"(0)
-    lt rx1260_pos, -1, rx1260_done
-    eq rx1260_pos, -1, rx1260_fail
+    rx1228_cur."!cursor_debug"("NEXT ", "infix:sym<=:=>")
+  rx1228_fail:
+    (rx1228_rep, rx1228_pos, $I10, $P10) = rx1228_cur."!mark_fail"(0)
+    lt rx1228_pos, -1, rx1228_done
+    eq rx1228_pos, -1, rx1228_fail
     jump $I10
-  rx1260_done:
-    rx1260_cur."!cursor_fail"()
-    rx1260_cur."!cursor_debug"("FAIL  ", "infix:sym<=:=>")
-    .return (rx1260_cur)
+  rx1228_done:
+    rx1228_cur."!cursor_fail"()
+    rx1228_cur."!cursor_debug"("FAIL  ", "infix:sym<=:=>")
+    .return (rx1228_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<=:=>"  :subid("319_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<=:=>"  :subid("319_1279529226.73787") :method
 .annotate 'line', 447
-    $P1262 = self."!PREFIX__!subrule"("O", "=:=")
-    new $P1263, "ResizablePMCArray"
-    push $P1263, $P1262
-    .return ($P1263)
+    $P1230 = self."!PREFIX__!subrule"("O", "=:=")
+    new $P1231, "ResizablePMCArray"
+    push $P1231, $P1230
+    .return ($P1231)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<~~>"  :subid("320_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<~~>"  :subid("320_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1267_tgt
-    .local int rx1267_pos
-    .local int rx1267_off
-    .local int rx1267_eos
-    .local int rx1267_rep
-    .local pmc rx1267_cur
-    (rx1267_cur, rx1267_pos, rx1267_tgt) = self."!cursor_start"()
-    rx1267_cur."!cursor_debug"("START ", "infix:sym<~~>")
-    .lex unicode:"$\x{a2}", rx1267_cur
+    .local string rx1235_tgt
+    .local int rx1235_pos
+    .local int rx1235_off
+    .local int rx1235_eos
+    .local int rx1235_rep
+    .local pmc rx1235_cur
+    (rx1235_cur, rx1235_pos, rx1235_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1235_cur
     .local pmc match
     .lex "$/", match
-    length rx1267_eos, rx1267_tgt
-    gt rx1267_pos, rx1267_eos, rx1267_done
-    set rx1267_off, 0
-    lt rx1267_pos, 2, rx1267_start
-    sub rx1267_off, rx1267_pos, 1
-    substr rx1267_tgt, rx1267_tgt, rx1267_off
-  rx1267_start:
+    length rx1235_eos, rx1235_tgt
+    gt rx1235_pos, rx1235_eos, rx1235_done
+    set rx1235_off, 0
+    lt rx1235_pos, 2, rx1235_start
+    sub rx1235_off, rx1235_pos, 1
+    substr rx1235_tgt, rx1235_tgt, rx1235_off
+  rx1235_start:
+    eq $I10, 1, rx1235_restart
+    rx1235_cur."!cursor_debug"("START ", "infix:sym<~~>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1271_done
-    goto rxscan1271_scan
-  rxscan1271_loop:
-    ($P10) = rx1267_cur."from"()
+    ne $I10, -1, rxscan1239_done
+    goto rxscan1239_scan
+  rxscan1239_loop:
+    ($P10) = rx1235_cur."from"()
     inc $P10
-    set rx1267_pos, $P10
-    ge rx1267_pos, rx1267_eos, rxscan1271_done
-  rxscan1271_scan:
-    set_addr $I10, rxscan1271_loop
-    rx1267_cur."!mark_push"(0, rx1267_pos, $I10)
-  rxscan1271_done:
+    set rx1235_pos, $P10
+    ge rx1235_pos, rx1235_eos, rxscan1239_done
+  rxscan1239_scan:
+    set_addr $I10, rxscan1239_loop
+    rx1235_cur."!mark_push"(0, rx1235_pos, $I10)
+  rxscan1239_done:
 .annotate 'line', 532
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1272_fail
-    rx1267_cur."!mark_push"(0, rx1267_pos, $I10)
+    set_addr $I10, rxcap_1240_fail
+    rx1235_cur."!mark_push"(0, rx1235_pos, $I10)
   # rx literal  "~~"
-    add $I11, rx1267_pos, 2
-    gt $I11, rx1267_eos, rx1267_fail
-    sub $I11, rx1267_pos, rx1267_off
-    substr $S10, rx1267_tgt, $I11, 2
-    ne $S10, "~~", rx1267_fail
-    add rx1267_pos, 2
-    set_addr $I10, rxcap_1272_fail
-    ($I12, $I11) = rx1267_cur."!mark_peek"($I10)
-    rx1267_cur."!cursor_pos"($I11)
-    ($P10) = rx1267_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1267_pos, "")
-    rx1267_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1235_pos, 2
+    gt $I11, rx1235_eos, rx1235_fail
+    sub $I11, rx1235_pos, rx1235_off
+    substr $S10, rx1235_tgt, $I11, 2
+    ne $S10, "~~", rx1235_fail
+    add rx1235_pos, 2
+    set_addr $I10, rxcap_1240_fail
+    ($I12, $I11) = rx1235_cur."!mark_peek"($I10)
+    rx1235_cur."!cursor_pos"($I11)
+    ($P10) = rx1235_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1235_pos, "")
+    rx1235_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1272_done
-  rxcap_1272_fail:
-    goto rx1267_fail
-  rxcap_1272_done:
+    goto rxcap_1240_done
+  rxcap_1240_fail:
+    goto rx1235_fail
+  rxcap_1240_done:
   # rx subrule "O" subtype=capture negate=
-    rx1267_cur."!cursor_pos"(rx1267_pos)
-    $P10 = rx1267_cur."O"("%relational, :reducecheck<smartmatch>")
-    unless $P10, rx1267_fail
-    rx1267_cur."!mark_push"(0, -1, 0, $P10)
+    rx1235_cur."!cursor_pos"(rx1235_pos)
+    $P10 = rx1235_cur."O"("%relational, :reducecheck<smartmatch>")
+    unless $P10, rx1235_fail
+    rx1235_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1267_pos = $P10."pos"()
+    rx1235_pos = $P10."pos"()
   # rx pass
-    rx1267_cur."!cursor_pass"(rx1267_pos, "infix:sym<~~>")
-    rx1267_cur."!cursor_debug"("PASS  ", "infix:sym<~~>", " at pos=", rx1267_pos)
-    .return (rx1267_cur)
-  rx1267_fail:
+    rx1235_cur."!cursor_pass"(rx1235_pos, "infix:sym<~~>")
+    rx1235_cur."!cursor_debug"("PASS  ", "infix:sym<~~>", " at pos=", rx1235_pos)
+    .return (rx1235_cur)
+  rx1235_restart:
 .annotate 'line', 447
-    (rx1267_rep, rx1267_pos, $I10, $P10) = rx1267_cur."!mark_fail"(0)
-    lt rx1267_pos, -1, rx1267_done
-    eq rx1267_pos, -1, rx1267_fail
+    rx1235_cur."!cursor_debug"("NEXT ", "infix:sym<~~>")
+  rx1235_fail:
+    (rx1235_rep, rx1235_pos, $I10, $P10) = rx1235_cur."!mark_fail"(0)
+    lt rx1235_pos, -1, rx1235_done
+    eq rx1235_pos, -1, rx1235_fail
     jump $I10
-  rx1267_done:
-    rx1267_cur."!cursor_fail"()
-    rx1267_cur."!cursor_debug"("FAIL  ", "infix:sym<~~>")
-    .return (rx1267_cur)
+  rx1235_done:
+    rx1235_cur."!cursor_fail"()
+    rx1235_cur."!cursor_debug"("FAIL  ", "infix:sym<~~>")
+    .return (rx1235_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<~~>"  :subid("321_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<~~>"  :subid("321_1279529226.73787") :method
 .annotate 'line', 447
-    $P1269 = self."!PREFIX__!subrule"("O", "~~")
-    new $P1270, "ResizablePMCArray"
-    push $P1270, $P1269
-    .return ($P1270)
+    $P1237 = self."!PREFIX__!subrule"("O", "~~")
+    new $P1238, "ResizablePMCArray"
+    push $P1238, $P1237
+    .return ($P1238)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<&&>"  :subid("322_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<&&>"  :subid("322_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1274_tgt
-    .local int rx1274_pos
-    .local int rx1274_off
-    .local int rx1274_eos
-    .local int rx1274_rep
-    .local pmc rx1274_cur
-    (rx1274_cur, rx1274_pos, rx1274_tgt) = self."!cursor_start"()
-    rx1274_cur."!cursor_debug"("START ", "infix:sym<&&>")
-    .lex unicode:"$\x{a2}", rx1274_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1274_eos, rx1274_tgt
-    gt rx1274_pos, rx1274_eos, rx1274_done
-    set rx1274_off, 0
-    lt rx1274_pos, 2, rx1274_start
-    sub rx1274_off, rx1274_pos, 1
-    substr rx1274_tgt, rx1274_tgt, rx1274_off
-  rx1274_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1278_done
-    goto rxscan1278_scan
-  rxscan1278_loop:
-    ($P10) = rx1274_cur."from"()
-    inc $P10
-    set rx1274_pos, $P10
-    ge rx1274_pos, rx1274_eos, rxscan1278_done
-  rxscan1278_scan:
-    set_addr $I10, rxscan1278_loop
-    rx1274_cur."!mark_push"(0, rx1274_pos, $I10)
-  rxscan1278_done:
+    .local string rx1242_tgt
+    .local int rx1242_pos
+    .local int rx1242_off
+    .local int rx1242_eos
+    .local int rx1242_rep
+    .local pmc rx1242_cur
+    (rx1242_cur, rx1242_pos, rx1242_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1242_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1242_eos, rx1242_tgt
+    gt rx1242_pos, rx1242_eos, rx1242_done
+    set rx1242_off, 0
+    lt rx1242_pos, 2, rx1242_start
+    sub rx1242_off, rx1242_pos, 1
+    substr rx1242_tgt, rx1242_tgt, rx1242_off
+  rx1242_start:
+    eq $I10, 1, rx1242_restart
+    rx1242_cur."!cursor_debug"("START ", "infix:sym<&&>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1246_done
+    goto rxscan1246_scan
+  rxscan1246_loop:
+    ($P10) = rx1242_cur."from"()
+    inc $P10
+    set rx1242_pos, $P10
+    ge rx1242_pos, rx1242_eos, rxscan1246_done
+  rxscan1246_scan:
+    set_addr $I10, rxscan1246_loop
+    rx1242_cur."!mark_push"(0, rx1242_pos, $I10)
+  rxscan1246_done:
 .annotate 'line', 534
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1279_fail
-    rx1274_cur."!mark_push"(0, rx1274_pos, $I10)
+    set_addr $I10, rxcap_1247_fail
+    rx1242_cur."!mark_push"(0, rx1242_pos, $I10)
   # rx literal  "&&"
-    add $I11, rx1274_pos, 2
-    gt $I11, rx1274_eos, rx1274_fail
-    sub $I11, rx1274_pos, rx1274_off
-    substr $S10, rx1274_tgt, $I11, 2
-    ne $S10, "&&", rx1274_fail
-    add rx1274_pos, 2
-    set_addr $I10, rxcap_1279_fail
-    ($I12, $I11) = rx1274_cur."!mark_peek"($I10)
-    rx1274_cur."!cursor_pos"($I11)
-    ($P10) = rx1274_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1274_pos, "")
-    rx1274_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1242_pos, 2
+    gt $I11, rx1242_eos, rx1242_fail
+    sub $I11, rx1242_pos, rx1242_off
+    substr $S10, rx1242_tgt, $I11, 2
+    ne $S10, "&&", rx1242_fail
+    add rx1242_pos, 2
+    set_addr $I10, rxcap_1247_fail
+    ($I12, $I11) = rx1242_cur."!mark_peek"($I10)
+    rx1242_cur."!cursor_pos"($I11)
+    ($P10) = rx1242_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1242_pos, "")
+    rx1242_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1279_done
-  rxcap_1279_fail:
-    goto rx1274_fail
-  rxcap_1279_done:
+    goto rxcap_1247_done
+  rxcap_1247_fail:
+    goto rx1242_fail
+  rxcap_1247_done:
   # rx subrule "O" subtype=capture negate=
-    rx1274_cur."!cursor_pos"(rx1274_pos)
-    $P10 = rx1274_cur."O"("%tight_and, :pasttype<if>")
-    unless $P10, rx1274_fail
-    rx1274_cur."!mark_push"(0, -1, 0, $P10)
+    rx1242_cur."!cursor_pos"(rx1242_pos)
+    $P10 = rx1242_cur."O"("%tight_and, :pasttype<if>")
+    unless $P10, rx1242_fail
+    rx1242_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1274_pos = $P10."pos"()
+    rx1242_pos = $P10."pos"()
   # rx pass
-    rx1274_cur."!cursor_pass"(rx1274_pos, "infix:sym<&&>")
-    rx1274_cur."!cursor_debug"("PASS  ", "infix:sym<&&>", " at pos=", rx1274_pos)
-    .return (rx1274_cur)
-  rx1274_fail:
+    rx1242_cur."!cursor_pass"(rx1242_pos, "infix:sym<&&>")
+    rx1242_cur."!cursor_debug"("PASS  ", "infix:sym<&&>", " at pos=", rx1242_pos)
+    .return (rx1242_cur)
+  rx1242_restart:
 .annotate 'line', 447
-    (rx1274_rep, rx1274_pos, $I10, $P10) = rx1274_cur."!mark_fail"(0)
-    lt rx1274_pos, -1, rx1274_done
-    eq rx1274_pos, -1, rx1274_fail
+    rx1242_cur."!cursor_debug"("NEXT ", "infix:sym<&&>")
+  rx1242_fail:
+    (rx1242_rep, rx1242_pos, $I10, $P10) = rx1242_cur."!mark_fail"(0)
+    lt rx1242_pos, -1, rx1242_done
+    eq rx1242_pos, -1, rx1242_fail
     jump $I10
-  rx1274_done:
-    rx1274_cur."!cursor_fail"()
-    rx1274_cur."!cursor_debug"("FAIL  ", "infix:sym<&&>")
-    .return (rx1274_cur)
+  rx1242_done:
+    rx1242_cur."!cursor_fail"()
+    rx1242_cur."!cursor_debug"("FAIL  ", "infix:sym<&&>")
+    .return (rx1242_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<&&>"  :subid("323_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<&&>"  :subid("323_1279529226.73787") :method
 .annotate 'line', 447
-    $P1276 = self."!PREFIX__!subrule"("O", "&&")
-    new $P1277, "ResizablePMCArray"
-    push $P1277, $P1276
-    .return ($P1277)
+    $P1244 = self."!PREFIX__!subrule"("O", "&&")
+    new $P1245, "ResizablePMCArray"
+    push $P1245, $P1244
+    .return ($P1245)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<||>"  :subid("324_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<||>"  :subid("324_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1281_tgt
-    .local int rx1281_pos
-    .local int rx1281_off
-    .local int rx1281_eos
-    .local int rx1281_rep
-    .local pmc rx1281_cur
-    (rx1281_cur, rx1281_pos, rx1281_tgt) = self."!cursor_start"()
-    rx1281_cur."!cursor_debug"("START ", "infix:sym<||>")
-    .lex unicode:"$\x{a2}", rx1281_cur
+    .local string rx1249_tgt
+    .local int rx1249_pos
+    .local int rx1249_off
+    .local int rx1249_eos
+    .local int rx1249_rep
+    .local pmc rx1249_cur
+    (rx1249_cur, rx1249_pos, rx1249_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1249_cur
     .local pmc match
     .lex "$/", match
-    length rx1281_eos, rx1281_tgt
-    gt rx1281_pos, rx1281_eos, rx1281_done
-    set rx1281_off, 0
-    lt rx1281_pos, 2, rx1281_start
-    sub rx1281_off, rx1281_pos, 1
-    substr rx1281_tgt, rx1281_tgt, rx1281_off
-  rx1281_start:
+    length rx1249_eos, rx1249_tgt
+    gt rx1249_pos, rx1249_eos, rx1249_done
+    set rx1249_off, 0
+    lt rx1249_pos, 2, rx1249_start
+    sub rx1249_off, rx1249_pos, 1
+    substr rx1249_tgt, rx1249_tgt, rx1249_off
+  rx1249_start:
+    eq $I10, 1, rx1249_restart
+    rx1249_cur."!cursor_debug"("START ", "infix:sym<||>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1285_done
-    goto rxscan1285_scan
-  rxscan1285_loop:
-    ($P10) = rx1281_cur."from"()
+    ne $I10, -1, rxscan1253_done
+    goto rxscan1253_scan
+  rxscan1253_loop:
+    ($P10) = rx1249_cur."from"()
     inc $P10
-    set rx1281_pos, $P10
-    ge rx1281_pos, rx1281_eos, rxscan1285_done
-  rxscan1285_scan:
-    set_addr $I10, rxscan1285_loop
-    rx1281_cur."!mark_push"(0, rx1281_pos, $I10)
-  rxscan1285_done:
+    set rx1249_pos, $P10
+    ge rx1249_pos, rx1249_eos, rxscan1253_done
+  rxscan1253_scan:
+    set_addr $I10, rxscan1253_loop
+    rx1249_cur."!mark_push"(0, rx1249_pos, $I10)
+  rxscan1253_done:
 .annotate 'line', 536
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1286_fail
-    rx1281_cur."!mark_push"(0, rx1281_pos, $I10)
+    set_addr $I10, rxcap_1254_fail
+    rx1249_cur."!mark_push"(0, rx1249_pos, $I10)
   # rx literal  "||"
-    add $I11, rx1281_pos, 2
-    gt $I11, rx1281_eos, rx1281_fail
-    sub $I11, rx1281_pos, rx1281_off
-    substr $S10, rx1281_tgt, $I11, 2
-    ne $S10, "||", rx1281_fail
-    add rx1281_pos, 2
-    set_addr $I10, rxcap_1286_fail
-    ($I12, $I11) = rx1281_cur."!mark_peek"($I10)
-    rx1281_cur."!cursor_pos"($I11)
-    ($P10) = rx1281_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1281_pos, "")
-    rx1281_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1249_pos, 2
+    gt $I11, rx1249_eos, rx1249_fail
+    sub $I11, rx1249_pos, rx1249_off
+    substr $S10, rx1249_tgt, $I11, 2
+    ne $S10, "||", rx1249_fail
+    add rx1249_pos, 2
+    set_addr $I10, rxcap_1254_fail
+    ($I12, $I11) = rx1249_cur."!mark_peek"($I10)
+    rx1249_cur."!cursor_pos"($I11)
+    ($P10) = rx1249_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1249_pos, "")
+    rx1249_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1286_done
-  rxcap_1286_fail:
-    goto rx1281_fail
-  rxcap_1286_done:
+    goto rxcap_1254_done
+  rxcap_1254_fail:
+    goto rx1249_fail
+  rxcap_1254_done:
   # rx subrule "O" subtype=capture negate=
-    rx1281_cur."!cursor_pos"(rx1281_pos)
-    $P10 = rx1281_cur."O"("%tight_or, :pasttype<unless>")
-    unless $P10, rx1281_fail
-    rx1281_cur."!mark_push"(0, -1, 0, $P10)
+    rx1249_cur."!cursor_pos"(rx1249_pos)
+    $P10 = rx1249_cur."O"("%tight_or, :pasttype<unless>")
+    unless $P10, rx1249_fail
+    rx1249_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1281_pos = $P10."pos"()
+    rx1249_pos = $P10."pos"()
   # rx pass
-    rx1281_cur."!cursor_pass"(rx1281_pos, "infix:sym<||>")
-    rx1281_cur."!cursor_debug"("PASS  ", "infix:sym<||>", " at pos=", rx1281_pos)
-    .return (rx1281_cur)
-  rx1281_fail:
+    rx1249_cur."!cursor_pass"(rx1249_pos, "infix:sym<||>")
+    rx1249_cur."!cursor_debug"("PASS  ", "infix:sym<||>", " at pos=", rx1249_pos)
+    .return (rx1249_cur)
+  rx1249_restart:
 .annotate 'line', 447
-    (rx1281_rep, rx1281_pos, $I10, $P10) = rx1281_cur."!mark_fail"(0)
-    lt rx1281_pos, -1, rx1281_done
-    eq rx1281_pos, -1, rx1281_fail
+    rx1249_cur."!cursor_debug"("NEXT ", "infix:sym<||>")
+  rx1249_fail:
+    (rx1249_rep, rx1249_pos, $I10, $P10) = rx1249_cur."!mark_fail"(0)
+    lt rx1249_pos, -1, rx1249_done
+    eq rx1249_pos, -1, rx1249_fail
     jump $I10
-  rx1281_done:
-    rx1281_cur."!cursor_fail"()
-    rx1281_cur."!cursor_debug"("FAIL  ", "infix:sym<||>")
-    .return (rx1281_cur)
+  rx1249_done:
+    rx1249_cur."!cursor_fail"()
+    rx1249_cur."!cursor_debug"("FAIL  ", "infix:sym<||>")
+    .return (rx1249_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<||>"  :subid("325_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<||>"  :subid("325_1279529226.73787") :method
 .annotate 'line', 447
-    $P1283 = self."!PREFIX__!subrule"("O", "||")
-    new $P1284, "ResizablePMCArray"
-    push $P1284, $P1283
-    .return ($P1284)
+    $P1251 = self."!PREFIX__!subrule"("O", "||")
+    new $P1252, "ResizablePMCArray"
+    push $P1252, $P1251
+    .return ($P1252)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<//>"  :subid("326_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<//>"  :subid("326_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1288_tgt
-    .local int rx1288_pos
-    .local int rx1288_off
-    .local int rx1288_eos
-    .local int rx1288_rep
-    .local pmc rx1288_cur
-    (rx1288_cur, rx1288_pos, rx1288_tgt) = self."!cursor_start"()
-    rx1288_cur."!cursor_debug"("START ", "infix:sym<//>")
-    .lex unicode:"$\x{a2}", rx1288_cur
+    .local string rx1256_tgt
+    .local int rx1256_pos
+    .local int rx1256_off
+    .local int rx1256_eos
+    .local int rx1256_rep
+    .local pmc rx1256_cur
+    (rx1256_cur, rx1256_pos, rx1256_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1256_cur
     .local pmc match
     .lex "$/", match
-    length rx1288_eos, rx1288_tgt
-    gt rx1288_pos, rx1288_eos, rx1288_done
-    set rx1288_off, 0
-    lt rx1288_pos, 2, rx1288_start
-    sub rx1288_off, rx1288_pos, 1
-    substr rx1288_tgt, rx1288_tgt, rx1288_off
-  rx1288_start:
+    length rx1256_eos, rx1256_tgt
+    gt rx1256_pos, rx1256_eos, rx1256_done
+    set rx1256_off, 0
+    lt rx1256_pos, 2, rx1256_start
+    sub rx1256_off, rx1256_pos, 1
+    substr rx1256_tgt, rx1256_tgt, rx1256_off
+  rx1256_start:
+    eq $I10, 1, rx1256_restart
+    rx1256_cur."!cursor_debug"("START ", "infix:sym<//>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1292_done
-    goto rxscan1292_scan
-  rxscan1292_loop:
-    ($P10) = rx1288_cur."from"()
+    ne $I10, -1, rxscan1260_done
+    goto rxscan1260_scan
+  rxscan1260_loop:
+    ($P10) = rx1256_cur."from"()
     inc $P10
-    set rx1288_pos, $P10
-    ge rx1288_pos, rx1288_eos, rxscan1292_done
-  rxscan1292_scan:
-    set_addr $I10, rxscan1292_loop
-    rx1288_cur."!mark_push"(0, rx1288_pos, $I10)
-  rxscan1292_done:
+    set rx1256_pos, $P10
+    ge rx1256_pos, rx1256_eos, rxscan1260_done
+  rxscan1260_scan:
+    set_addr $I10, rxscan1260_loop
+    rx1256_cur."!mark_push"(0, rx1256_pos, $I10)
+  rxscan1260_done:
 .annotate 'line', 537
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1293_fail
-    rx1288_cur."!mark_push"(0, rx1288_pos, $I10)
+    set_addr $I10, rxcap_1261_fail
+    rx1256_cur."!mark_push"(0, rx1256_pos, $I10)
   # rx literal  "//"
-    add $I11, rx1288_pos, 2
-    gt $I11, rx1288_eos, rx1288_fail
-    sub $I11, rx1288_pos, rx1288_off
-    substr $S10, rx1288_tgt, $I11, 2
-    ne $S10, "//", rx1288_fail
-    add rx1288_pos, 2
-    set_addr $I10, rxcap_1293_fail
-    ($I12, $I11) = rx1288_cur."!mark_peek"($I10)
-    rx1288_cur."!cursor_pos"($I11)
-    ($P10) = rx1288_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1288_pos, "")
-    rx1288_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1256_pos, 2
+    gt $I11, rx1256_eos, rx1256_fail
+    sub $I11, rx1256_pos, rx1256_off
+    substr $S10, rx1256_tgt, $I11, 2
+    ne $S10, "//", rx1256_fail
+    add rx1256_pos, 2
+    set_addr $I10, rxcap_1261_fail
+    ($I12, $I11) = rx1256_cur."!mark_peek"($I10)
+    rx1256_cur."!cursor_pos"($I11)
+    ($P10) = rx1256_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1256_pos, "")
+    rx1256_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1293_done
-  rxcap_1293_fail:
-    goto rx1288_fail
-  rxcap_1293_done:
+    goto rxcap_1261_done
+  rxcap_1261_fail:
+    goto rx1256_fail
+  rxcap_1261_done:
   # rx subrule "O" subtype=capture negate=
-    rx1288_cur."!cursor_pos"(rx1288_pos)
-    $P10 = rx1288_cur."O"("%tight_or, :pasttype<def_or>")
-    unless $P10, rx1288_fail
-    rx1288_cur."!mark_push"(0, -1, 0, $P10)
+    rx1256_cur."!cursor_pos"(rx1256_pos)
+    $P10 = rx1256_cur."O"("%tight_or, :pasttype<def_or>")
+    unless $P10, rx1256_fail
+    rx1256_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1288_pos = $P10."pos"()
+    rx1256_pos = $P10."pos"()
   # rx pass
-    rx1288_cur."!cursor_pass"(rx1288_pos, "infix:sym<//>")
-    rx1288_cur."!cursor_debug"("PASS  ", "infix:sym<//>", " at pos=", rx1288_pos)
-    .return (rx1288_cur)
-  rx1288_fail:
+    rx1256_cur."!cursor_pass"(rx1256_pos, "infix:sym<//>")
+    rx1256_cur."!cursor_debug"("PASS  ", "infix:sym<//>", " at pos=", rx1256_pos)
+    .return (rx1256_cur)
+  rx1256_restart:
 .annotate 'line', 447
-    (rx1288_rep, rx1288_pos, $I10, $P10) = rx1288_cur."!mark_fail"(0)
-    lt rx1288_pos, -1, rx1288_done
-    eq rx1288_pos, -1, rx1288_fail
+    rx1256_cur."!cursor_debug"("NEXT ", "infix:sym<//>")
+  rx1256_fail:
+    (rx1256_rep, rx1256_pos, $I10, $P10) = rx1256_cur."!mark_fail"(0)
+    lt rx1256_pos, -1, rx1256_done
+    eq rx1256_pos, -1, rx1256_fail
     jump $I10
-  rx1288_done:
-    rx1288_cur."!cursor_fail"()
-    rx1288_cur."!cursor_debug"("FAIL  ", "infix:sym<//>")
-    .return (rx1288_cur)
+  rx1256_done:
+    rx1256_cur."!cursor_fail"()
+    rx1256_cur."!cursor_debug"("FAIL  ", "infix:sym<//>")
+    .return (rx1256_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<//>"  :subid("327_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<//>"  :subid("327_1279529226.73787") :method
 .annotate 'line', 447
-    $P1290 = self."!PREFIX__!subrule"("O", "//")
-    new $P1291, "ResizablePMCArray"
-    push $P1291, $P1290
-    .return ($P1291)
+    $P1258 = self."!PREFIX__!subrule"("O", "//")
+    new $P1259, "ResizablePMCArray"
+    push $P1259, $P1258
+    .return ($P1259)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<?? !!>"  :subid("328_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<?? !!>"  :subid("328_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1295_tgt
-    .local int rx1295_pos
-    .local int rx1295_off
-    .local int rx1295_eos
-    .local int rx1295_rep
-    .local pmc rx1295_cur
-    (rx1295_cur, rx1295_pos, rx1295_tgt) = self."!cursor_start"()
-    rx1295_cur."!cursor_debug"("START ", "infix:sym<?? !!>")
-    .lex unicode:"$\x{a2}", rx1295_cur
+    .local string rx1263_tgt
+    .local int rx1263_pos
+    .local int rx1263_off
+    .local int rx1263_eos
+    .local int rx1263_rep
+    .local pmc rx1263_cur
+    (rx1263_cur, rx1263_pos, rx1263_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1263_cur
     .local pmc match
     .lex "$/", match
-    length rx1295_eos, rx1295_tgt
-    gt rx1295_pos, rx1295_eos, rx1295_done
-    set rx1295_off, 0
-    lt rx1295_pos, 2, rx1295_start
-    sub rx1295_off, rx1295_pos, 1
-    substr rx1295_tgt, rx1295_tgt, rx1295_off
-  rx1295_start:
+    length rx1263_eos, rx1263_tgt
+    gt rx1263_pos, rx1263_eos, rx1263_done
+    set rx1263_off, 0
+    lt rx1263_pos, 2, rx1263_start
+    sub rx1263_off, rx1263_pos, 1
+    substr rx1263_tgt, rx1263_tgt, rx1263_off
+  rx1263_start:
+    eq $I10, 1, rx1263_restart
+    rx1263_cur."!cursor_debug"("START ", "infix:sym<?? !!>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1299_done
-    goto rxscan1299_scan
-  rxscan1299_loop:
-    ($P10) = rx1295_cur."from"()
+    ne $I10, -1, rxscan1267_done
+    goto rxscan1267_scan
+  rxscan1267_loop:
+    ($P10) = rx1263_cur."from"()
     inc $P10
-    set rx1295_pos, $P10
-    ge rx1295_pos, rx1295_eos, rxscan1299_done
-  rxscan1299_scan:
-    set_addr $I10, rxscan1299_loop
-    rx1295_cur."!mark_push"(0, rx1295_pos, $I10)
-  rxscan1299_done:
+    set rx1263_pos, $P10
+    ge rx1263_pos, rx1263_eos, rxscan1267_done
+  rxscan1267_scan:
+    set_addr $I10, rxscan1267_loop
+    rx1263_cur."!mark_push"(0, rx1263_pos, $I10)
+  rxscan1267_done:
 .annotate 'line', 540
   # rx literal  "??"
-    add $I11, rx1295_pos, 2
-    gt $I11, rx1295_eos, rx1295_fail
-    sub $I11, rx1295_pos, rx1295_off
-    substr $S10, rx1295_tgt, $I11, 2
-    ne $S10, "??", rx1295_fail
-    add rx1295_pos, 2
+    add $I11, rx1263_pos, 2
+    gt $I11, rx1263_eos, rx1263_fail
+    sub $I11, rx1263_pos, rx1263_off
+    substr $S10, rx1263_tgt, $I11, 2
+    ne $S10, "??", rx1263_fail
+    add rx1263_pos, 2
 .annotate 'line', 541
   # rx subrule "ws" subtype=method negate=
-    rx1295_cur."!cursor_pos"(rx1295_pos)
-    $P10 = rx1295_cur."ws"()
-    unless $P10, rx1295_fail
-    rx1295_pos = $P10."pos"()
+    rx1263_cur."!cursor_pos"(rx1263_pos)
+    $P10 = rx1263_cur."ws"()
+    unless $P10, rx1263_fail
+    rx1263_pos = $P10."pos"()
 .annotate 'line', 542
   # rx subrule "EXPR" subtype=capture negate=
-    rx1295_cur."!cursor_pos"(rx1295_pos)
-    $P10 = rx1295_cur."EXPR"("i=")
-    unless $P10, rx1295_fail
-    rx1295_cur."!mark_push"(0, -1, 0, $P10)
+    rx1263_cur."!cursor_pos"(rx1263_pos)
+    $P10 = rx1263_cur."EXPR"("i=")
+    unless $P10, rx1263_fail
+    rx1263_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("EXPR")
-    rx1295_pos = $P10."pos"()
+    rx1263_pos = $P10."pos"()
 .annotate 'line', 543
   # rx literal  "!!"
-    add $I11, rx1295_pos, 2
-    gt $I11, rx1295_eos, rx1295_fail
-    sub $I11, rx1295_pos, rx1295_off
-    substr $S10, rx1295_tgt, $I11, 2
-    ne $S10, "!!", rx1295_fail
-    add rx1295_pos, 2
+    add $I11, rx1263_pos, 2
+    gt $I11, rx1263_eos, rx1263_fail
+    sub $I11, rx1263_pos, rx1263_off
+    substr $S10, rx1263_tgt, $I11, 2
+    ne $S10, "!!", rx1263_fail
+    add rx1263_pos, 2
 .annotate 'line', 544
   # rx subrule "O" subtype=capture negate=
-    rx1295_cur."!cursor_pos"(rx1295_pos)
-    $P10 = rx1295_cur."O"("%conditional, :reducecheck<ternary>, :pasttype<if>")
-    unless $P10, rx1295_fail
-    rx1295_cur."!mark_push"(0, -1, 0, $P10)
+    rx1263_cur."!cursor_pos"(rx1263_pos)
+    $P10 = rx1263_cur."O"("%conditional, :reducecheck<ternary>, :pasttype<if>")
+    unless $P10, rx1263_fail
+    rx1263_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1295_pos = $P10."pos"()
+    rx1263_pos = $P10."pos"()
 .annotate 'line', 539
   # rx pass
-    rx1295_cur."!cursor_pass"(rx1295_pos, "infix:sym<?? !!>")
-    rx1295_cur."!cursor_debug"("PASS  ", "infix:sym<?? !!>", " at pos=", rx1295_pos)
-    .return (rx1295_cur)
-  rx1295_fail:
+    rx1263_cur."!cursor_pass"(rx1263_pos, "infix:sym<?? !!>")
+    rx1263_cur."!cursor_debug"("PASS  ", "infix:sym<?? !!>", " at pos=", rx1263_pos)
+    .return (rx1263_cur)
+  rx1263_restart:
 .annotate 'line', 447
-    (rx1295_rep, rx1295_pos, $I10, $P10) = rx1295_cur."!mark_fail"(0)
-    lt rx1295_pos, -1, rx1295_done
-    eq rx1295_pos, -1, rx1295_fail
+    rx1263_cur."!cursor_debug"("NEXT ", "infix:sym<?? !!>")
+  rx1263_fail:
+    (rx1263_rep, rx1263_pos, $I10, $P10) = rx1263_cur."!mark_fail"(0)
+    lt rx1263_pos, -1, rx1263_done
+    eq rx1263_pos, -1, rx1263_fail
     jump $I10
-  rx1295_done:
-    rx1295_cur."!cursor_fail"()
-    rx1295_cur."!cursor_debug"("FAIL  ", "infix:sym<?? !!>")
-    .return (rx1295_cur)
+  rx1263_done:
+    rx1263_cur."!cursor_fail"()
+    rx1263_cur."!cursor_debug"("FAIL  ", "infix:sym<?? !!>")
+    .return (rx1263_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<?? !!>"  :subid("329_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<?? !!>"  :subid("329_1279529226.73787") :method
 .annotate 'line', 447
-    $P1297 = self."!PREFIX__!subrule"("ws", "??")
-    new $P1298, "ResizablePMCArray"
-    push $P1298, $P1297
-    .return ($P1298)
+    $P1265 = self."!PREFIX__!subrule"("ws", "??")
+    new $P1266, "ResizablePMCArray"
+    push $P1266, $P1265
+    .return ($P1266)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<=>"  :subid("330_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<=>"  :subid("330_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1301_tgt
-    .local int rx1301_pos
-    .local int rx1301_off
-    .local int rx1301_eos
-    .local int rx1301_rep
-    .local pmc rx1301_cur
-    (rx1301_cur, rx1301_pos, rx1301_tgt) = self."!cursor_start"()
-    rx1301_cur."!cursor_debug"("START ", "infix:sym<=>")
-    .lex unicode:"$\x{a2}", rx1301_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1301_eos, rx1301_tgt
-    gt rx1301_pos, rx1301_eos, rx1301_done
-    set rx1301_off, 0
-    lt rx1301_pos, 2, rx1301_start
-    sub rx1301_off, rx1301_pos, 1
-    substr rx1301_tgt, rx1301_tgt, rx1301_off
-  rx1301_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1305_done
-    goto rxscan1305_scan
-  rxscan1305_loop:
-    ($P10) = rx1301_cur."from"()
-    inc $P10
-    set rx1301_pos, $P10
-    ge rx1301_pos, rx1301_eos, rxscan1305_done
-  rxscan1305_scan:
-    set_addr $I10, rxscan1305_loop
-    rx1301_cur."!mark_push"(0, rx1301_pos, $I10)
-  rxscan1305_done:
+    .local string rx1269_tgt
+    .local int rx1269_pos
+    .local int rx1269_off
+    .local int rx1269_eos
+    .local int rx1269_rep
+    .local pmc rx1269_cur
+    (rx1269_cur, rx1269_pos, rx1269_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1269_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1269_eos, rx1269_tgt
+    gt rx1269_pos, rx1269_eos, rx1269_done
+    set rx1269_off, 0
+    lt rx1269_pos, 2, rx1269_start
+    sub rx1269_off, rx1269_pos, 1
+    substr rx1269_tgt, rx1269_tgt, rx1269_off
+  rx1269_start:
+    eq $I10, 1, rx1269_restart
+    rx1269_cur."!cursor_debug"("START ", "infix:sym<=>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1273_done
+    goto rxscan1273_scan
+  rxscan1273_loop:
+    ($P10) = rx1269_cur."from"()
+    inc $P10
+    set rx1269_pos, $P10
+    ge rx1269_pos, rx1269_eos, rxscan1273_done
+  rxscan1273_scan:
+    set_addr $I10, rxscan1273_loop
+    rx1269_cur."!mark_push"(0, rx1269_pos, $I10)
+  rxscan1273_done:
 .annotate 'line', 548
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1306_fail
-    rx1301_cur."!mark_push"(0, rx1301_pos, $I10)
+    set_addr $I10, rxcap_1274_fail
+    rx1269_cur."!mark_push"(0, rx1269_pos, $I10)
   # rx literal  "="
-    add $I11, rx1301_pos, 1
-    gt $I11, rx1301_eos, rx1301_fail
-    sub $I11, rx1301_pos, rx1301_off
-    substr $S10, rx1301_tgt, $I11, 1
-    ne $S10, "=", rx1301_fail
-    add rx1301_pos, 1
-    set_addr $I10, rxcap_1306_fail
-    ($I12, $I11) = rx1301_cur."!mark_peek"($I10)
-    rx1301_cur."!cursor_pos"($I11)
-    ($P10) = rx1301_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1301_pos, "")
-    rx1301_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1269_pos, 1
+    gt $I11, rx1269_eos, rx1269_fail
+    sub $I11, rx1269_pos, rx1269_off
+    substr $S10, rx1269_tgt, $I11, 1
+    ne $S10, "=", rx1269_fail
+    add rx1269_pos, 1
+    set_addr $I10, rxcap_1274_fail
+    ($I12, $I11) = rx1269_cur."!mark_peek"($I10)
+    rx1269_cur."!cursor_pos"($I11)
+    ($P10) = rx1269_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1269_pos, "")
+    rx1269_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1306_done
-  rxcap_1306_fail:
-    goto rx1301_fail
-  rxcap_1306_done:
+    goto rxcap_1274_done
+  rxcap_1274_fail:
+    goto rx1269_fail
+  rxcap_1274_done:
   # rx subrule "panic" subtype=method negate=
-    rx1301_cur."!cursor_pos"(rx1301_pos)
-    $P10 = rx1301_cur."panic"("Assignment (\"=\") not supported in NQP, use \":=\" instead")
-    unless $P10, rx1301_fail
-    rx1301_pos = $P10."pos"()
+    rx1269_cur."!cursor_pos"(rx1269_pos)
+    $P10 = rx1269_cur."panic"("Assignment (\"=\") not supported in NQP, use \":=\" instead")
+    unless $P10, rx1269_fail
+    rx1269_pos = $P10."pos"()
 .annotate 'line', 547
   # rx pass
-    rx1301_cur."!cursor_pass"(rx1301_pos, "infix:sym<=>")
-    rx1301_cur."!cursor_debug"("PASS  ", "infix:sym<=>", " at pos=", rx1301_pos)
-    .return (rx1301_cur)
-  rx1301_fail:
+    rx1269_cur."!cursor_pass"(rx1269_pos, "infix:sym<=>")
+    rx1269_cur."!cursor_debug"("PASS  ", "infix:sym<=>", " at pos=", rx1269_pos)
+    .return (rx1269_cur)
+  rx1269_restart:
 .annotate 'line', 447
-    (rx1301_rep, rx1301_pos, $I10, $P10) = rx1301_cur."!mark_fail"(0)
-    lt rx1301_pos, -1, rx1301_done
-    eq rx1301_pos, -1, rx1301_fail
+    rx1269_cur."!cursor_debug"("NEXT ", "infix:sym<=>")
+  rx1269_fail:
+    (rx1269_rep, rx1269_pos, $I10, $P10) = rx1269_cur."!mark_fail"(0)
+    lt rx1269_pos, -1, rx1269_done
+    eq rx1269_pos, -1, rx1269_fail
     jump $I10
-  rx1301_done:
-    rx1301_cur."!cursor_fail"()
-    rx1301_cur."!cursor_debug"("FAIL  ", "infix:sym<=>")
-    .return (rx1301_cur)
+  rx1269_done:
+    rx1269_cur."!cursor_fail"()
+    rx1269_cur."!cursor_debug"("FAIL  ", "infix:sym<=>")
+    .return (rx1269_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<=>"  :subid("331_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<=>"  :subid("331_1279529226.73787") :method
 .annotate 'line', 447
-    $P1303 = self."!PREFIX__!subrule"("panic", "=")
-    new $P1304, "ResizablePMCArray"
-    push $P1304, $P1303
-    .return ($P1304)
+    $P1271 = self."!PREFIX__!subrule"("panic", "=")
+    new $P1272, "ResizablePMCArray"
+    push $P1272, $P1271
+    .return ($P1272)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<:=>"  :subid("332_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<:=>"  :subid("332_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1308_tgt
-    .local int rx1308_pos
-    .local int rx1308_off
-    .local int rx1308_eos
-    .local int rx1308_rep
-    .local pmc rx1308_cur
-    (rx1308_cur, rx1308_pos, rx1308_tgt) = self."!cursor_start"()
-    rx1308_cur."!cursor_debug"("START ", "infix:sym<:=>")
-    .lex unicode:"$\x{a2}", rx1308_cur
+    .local string rx1276_tgt
+    .local int rx1276_pos
+    .local int rx1276_off
+    .local int rx1276_eos
+    .local int rx1276_rep
+    .local pmc rx1276_cur
+    (rx1276_cur, rx1276_pos, rx1276_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1276_cur
     .local pmc match
     .lex "$/", match
-    length rx1308_eos, rx1308_tgt
-    gt rx1308_pos, rx1308_eos, rx1308_done
-    set rx1308_off, 0
-    lt rx1308_pos, 2, rx1308_start
-    sub rx1308_off, rx1308_pos, 1
-    substr rx1308_tgt, rx1308_tgt, rx1308_off
-  rx1308_start:
+    length rx1276_eos, rx1276_tgt
+    gt rx1276_pos, rx1276_eos, rx1276_done
+    set rx1276_off, 0
+    lt rx1276_pos, 2, rx1276_start
+    sub rx1276_off, rx1276_pos, 1
+    substr rx1276_tgt, rx1276_tgt, rx1276_off
+  rx1276_start:
+    eq $I10, 1, rx1276_restart
+    rx1276_cur."!cursor_debug"("START ", "infix:sym<:=>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1312_done
-    goto rxscan1312_scan
-  rxscan1312_loop:
-    ($P10) = rx1308_cur."from"()
+    ne $I10, -1, rxscan1280_done
+    goto rxscan1280_scan
+  rxscan1280_loop:
+    ($P10) = rx1276_cur."from"()
     inc $P10
-    set rx1308_pos, $P10
-    ge rx1308_pos, rx1308_eos, rxscan1312_done
-  rxscan1312_scan:
-    set_addr $I10, rxscan1312_loop
-    rx1308_cur."!mark_push"(0, rx1308_pos, $I10)
-  rxscan1312_done:
+    set rx1276_pos, $P10
+    ge rx1276_pos, rx1276_eos, rxscan1280_done
+  rxscan1280_scan:
+    set_addr $I10, rxscan1280_loop
+    rx1276_cur."!mark_push"(0, rx1276_pos, $I10)
+  rxscan1280_done:
 .annotate 'line', 550
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1313_fail
-    rx1308_cur."!mark_push"(0, rx1308_pos, $I10)
+    set_addr $I10, rxcap_1281_fail
+    rx1276_cur."!mark_push"(0, rx1276_pos, $I10)
   # rx literal  ":="
-    add $I11, rx1308_pos, 2
-    gt $I11, rx1308_eos, rx1308_fail
-    sub $I11, rx1308_pos, rx1308_off
-    substr $S10, rx1308_tgt, $I11, 2
-    ne $S10, ":=", rx1308_fail
-    add rx1308_pos, 2
-    set_addr $I10, rxcap_1313_fail
-    ($I12, $I11) = rx1308_cur."!mark_peek"($I10)
-    rx1308_cur."!cursor_pos"($I11)
-    ($P10) = rx1308_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1308_pos, "")
-    rx1308_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1276_pos, 2
+    gt $I11, rx1276_eos, rx1276_fail
+    sub $I11, rx1276_pos, rx1276_off
+    substr $S10, rx1276_tgt, $I11, 2
+    ne $S10, ":=", rx1276_fail
+    add rx1276_pos, 2
+    set_addr $I10, rxcap_1281_fail
+    ($I12, $I11) = rx1276_cur."!mark_peek"($I10)
+    rx1276_cur."!cursor_pos"($I11)
+    ($P10) = rx1276_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1276_pos, "")
+    rx1276_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1313_done
-  rxcap_1313_fail:
-    goto rx1308_fail
-  rxcap_1313_done:
+    goto rxcap_1281_done
+  rxcap_1281_fail:
+    goto rx1276_fail
+  rxcap_1281_done:
   # rx subrule "O" subtype=capture negate=
-    rx1308_cur."!cursor_pos"(rx1308_pos)
-    $P10 = rx1308_cur."O"("%assignment, :pasttype<bind>")
-    unless $P10, rx1308_fail
-    rx1308_cur."!mark_push"(0, -1, 0, $P10)
+    rx1276_cur."!cursor_pos"(rx1276_pos)
+    $P10 = rx1276_cur."O"("%assignment, :pasttype<bind>")
+    unless $P10, rx1276_fail
+    rx1276_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1308_pos = $P10."pos"()
+    rx1276_pos = $P10."pos"()
   # rx pass
-    rx1308_cur."!cursor_pass"(rx1308_pos, "infix:sym<:=>")
-    rx1308_cur."!cursor_debug"("PASS  ", "infix:sym<:=>", " at pos=", rx1308_pos)
-    .return (rx1308_cur)
-  rx1308_fail:
+    rx1276_cur."!cursor_pass"(rx1276_pos, "infix:sym<:=>")
+    rx1276_cur."!cursor_debug"("PASS  ", "infix:sym<:=>", " at pos=", rx1276_pos)
+    .return (rx1276_cur)
+  rx1276_restart:
 .annotate 'line', 447
-    (rx1308_rep, rx1308_pos, $I10, $P10) = rx1308_cur."!mark_fail"(0)
-    lt rx1308_pos, -1, rx1308_done
-    eq rx1308_pos, -1, rx1308_fail
+    rx1276_cur."!cursor_debug"("NEXT ", "infix:sym<:=>")
+  rx1276_fail:
+    (rx1276_rep, rx1276_pos, $I10, $P10) = rx1276_cur."!mark_fail"(0)
+    lt rx1276_pos, -1, rx1276_done
+    eq rx1276_pos, -1, rx1276_fail
     jump $I10
-  rx1308_done:
-    rx1308_cur."!cursor_fail"()
-    rx1308_cur."!cursor_debug"("FAIL  ", "infix:sym<:=>")
-    .return (rx1308_cur)
+  rx1276_done:
+    rx1276_cur."!cursor_fail"()
+    rx1276_cur."!cursor_debug"("FAIL  ", "infix:sym<:=>")
+    .return (rx1276_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<:=>"  :subid("333_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<:=>"  :subid("333_1279529226.73787") :method
 .annotate 'line', 447
-    $P1310 = self."!PREFIX__!subrule"("O", ":=")
-    new $P1311, "ResizablePMCArray"
-    push $P1311, $P1310
-    .return ($P1311)
+    $P1278 = self."!PREFIX__!subrule"("O", ":=")
+    new $P1279, "ResizablePMCArray"
+    push $P1279, $P1278
+    .return ($P1279)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<::=>"  :subid("334_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "infix:sym<::=>"  :subid("334_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1315_tgt
-    .local int rx1315_pos
-    .local int rx1315_off
-    .local int rx1315_eos
-    .local int rx1315_rep
-    .local pmc rx1315_cur
-    (rx1315_cur, rx1315_pos, rx1315_tgt) = self."!cursor_start"()
-    rx1315_cur."!cursor_debug"("START ", "infix:sym<::=>")
-    .lex unicode:"$\x{a2}", rx1315_cur
+    .local string rx1283_tgt
+    .local int rx1283_pos
+    .local int rx1283_off
+    .local int rx1283_eos
+    .local int rx1283_rep
+    .local pmc rx1283_cur
+    (rx1283_cur, rx1283_pos, rx1283_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1283_cur
     .local pmc match
     .lex "$/", match
-    length rx1315_eos, rx1315_tgt
-    gt rx1315_pos, rx1315_eos, rx1315_done
-    set rx1315_off, 0
-    lt rx1315_pos, 2, rx1315_start
-    sub rx1315_off, rx1315_pos, 1
-    substr rx1315_tgt, rx1315_tgt, rx1315_off
-  rx1315_start:
+    length rx1283_eos, rx1283_tgt
+    gt rx1283_pos, rx1283_eos, rx1283_done
+    set rx1283_off, 0
+    lt rx1283_pos, 2, rx1283_start
+    sub rx1283_off, rx1283_pos, 1
+    substr rx1283_tgt, rx1283_tgt, rx1283_off
+  rx1283_start:
+    eq $I10, 1, rx1283_restart
+    rx1283_cur."!cursor_debug"("START ", "infix:sym<::=>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1319_done
-    goto rxscan1319_scan
-  rxscan1319_loop:
-    ($P10) = rx1315_cur."from"()
+    ne $I10, -1, rxscan1287_done
+    goto rxscan1287_scan
+  rxscan1287_loop:
+    ($P10) = rx1283_cur."from"()
     inc $P10
-    set rx1315_pos, $P10
-    ge rx1315_pos, rx1315_eos, rxscan1319_done
-  rxscan1319_scan:
-    set_addr $I10, rxscan1319_loop
-    rx1315_cur."!mark_push"(0, rx1315_pos, $I10)
-  rxscan1319_done:
+    set rx1283_pos, $P10
+    ge rx1283_pos, rx1283_eos, rxscan1287_done
+  rxscan1287_scan:
+    set_addr $I10, rxscan1287_loop
+    rx1283_cur."!mark_push"(0, rx1283_pos, $I10)
+  rxscan1287_done:
 .annotate 'line', 551
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1320_fail
-    rx1315_cur."!mark_push"(0, rx1315_pos, $I10)
+    set_addr $I10, rxcap_1288_fail
+    rx1283_cur."!mark_push"(0, rx1283_pos, $I10)
   # rx literal  "::="
-    add $I11, rx1315_pos, 3
-    gt $I11, rx1315_eos, rx1315_fail
-    sub $I11, rx1315_pos, rx1315_off
-    substr $S10, rx1315_tgt, $I11, 3
-    ne $S10, "::=", rx1315_fail
-    add rx1315_pos, 3
-    set_addr $I10, rxcap_1320_fail
-    ($I12, $I11) = rx1315_cur."!mark_peek"($I10)
-    rx1315_cur."!cursor_pos"($I11)
-    ($P10) = rx1315_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1315_pos, "")
-    rx1315_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1283_pos, 3
+    gt $I11, rx1283_eos, rx1283_fail
+    sub $I11, rx1283_pos, rx1283_off
+    substr $S10, rx1283_tgt, $I11, 3
+    ne $S10, "::=", rx1283_fail
+    add rx1283_pos, 3
+    set_addr $I10, rxcap_1288_fail
+    ($I12, $I11) = rx1283_cur."!mark_peek"($I10)
+    rx1283_cur."!cursor_pos"($I11)
+    ($P10) = rx1283_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1283_pos, "")
+    rx1283_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1320_done
-  rxcap_1320_fail:
-    goto rx1315_fail
-  rxcap_1320_done:
+    goto rxcap_1288_done
+  rxcap_1288_fail:
+    goto rx1283_fail
+  rxcap_1288_done:
   # rx subrule "O" subtype=capture negate=
-    rx1315_cur."!cursor_pos"(rx1315_pos)
-    $P10 = rx1315_cur."O"("%assignment, :pasttype<bind>")
-    unless $P10, rx1315_fail
-    rx1315_cur."!mark_push"(0, -1, 0, $P10)
+    rx1283_cur."!cursor_pos"(rx1283_pos)
+    $P10 = rx1283_cur."O"("%assignment, :pasttype<bind>")
+    unless $P10, rx1283_fail
+    rx1283_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1315_pos = $P10."pos"()
+    rx1283_pos = $P10."pos"()
   # rx pass
-    rx1315_cur."!cursor_pass"(rx1315_pos, "infix:sym<::=>")
-    rx1315_cur."!cursor_debug"("PASS  ", "infix:sym<::=>", " at pos=", rx1315_pos)
-    .return (rx1315_cur)
-  rx1315_fail:
+    rx1283_cur."!cursor_pass"(rx1283_pos, "infix:sym<::=>")
+    rx1283_cur."!cursor_debug"("PASS  ", "infix:sym<::=>", " at pos=", rx1283_pos)
+    .return (rx1283_cur)
+  rx1283_restart:
 .annotate 'line', 447
-    (rx1315_rep, rx1315_pos, $I10, $P10) = rx1315_cur."!mark_fail"(0)
-    lt rx1315_pos, -1, rx1315_done
-    eq rx1315_pos, -1, rx1315_fail
+    rx1283_cur."!cursor_debug"("NEXT ", "infix:sym<::=>")
+  rx1283_fail:
+    (rx1283_rep, rx1283_pos, $I10, $P10) = rx1283_cur."!mark_fail"(0)
+    lt rx1283_pos, -1, rx1283_done
+    eq rx1283_pos, -1, rx1283_fail
     jump $I10
-  rx1315_done:
-    rx1315_cur."!cursor_fail"()
-    rx1315_cur."!cursor_debug"("FAIL  ", "infix:sym<::=>")
-    .return (rx1315_cur)
+  rx1283_done:
+    rx1283_cur."!cursor_fail"()
+    rx1283_cur."!cursor_debug"("FAIL  ", "infix:sym<::=>")
+    .return (rx1283_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<::=>"  :subid("335_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<::=>"  :subid("335_1279529226.73787") :method
 .annotate 'line', 447
-    $P1317 = self."!PREFIX__!subrule"("O", "::=")
-    new $P1318, "ResizablePMCArray"
-    push $P1318, $P1317
-    .return ($P1318)
+    $P1285 = self."!PREFIX__!subrule"("O", "::=")
+    new $P1286, "ResizablePMCArray"
+    push $P1286, $P1285
+    .return ($P1286)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "infix:sym<,>"  :subid("336_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 447
-    .local string rx1322_tgt
-    .local int rx1322_pos
-    .local int rx1322_off
-    .local int rx1322_eos
-    .local int rx1322_rep
-    .local pmc rx1322_cur
-    (rx1322_cur, rx1322_pos, rx1322_tgt) = self."!cursor_start"()
-    rx1322_cur."!cursor_debug"("START ", "infix:sym<,>")
-    .lex unicode:"$\x{a2}", rx1322_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1322_eos, rx1322_tgt
-    gt rx1322_pos, rx1322_eos, rx1322_done
-    set rx1322_off, 0
-    lt rx1322_pos, 2, rx1322_start
-    sub rx1322_off, rx1322_pos, 1
-    substr rx1322_tgt, rx1322_tgt, rx1322_off
-  rx1322_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1326_done
-    goto rxscan1326_scan
-  rxscan1326_loop:
-    ($P10) = rx1322_cur."from"()
-    inc $P10
-    set rx1322_pos, $P10
-    ge rx1322_pos, rx1322_eos, rxscan1326_done
-  rxscan1326_scan:
-    set_addr $I10, rxscan1326_loop
-    rx1322_cur."!mark_push"(0, rx1322_pos, $I10)
-  rxscan1326_done:
+.sub "infix:sym<,>"  :subid("336_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 447
+    .local string rx1290_tgt
+    .local int rx1290_pos
+    .local int rx1290_off
+    .local int rx1290_eos
+    .local int rx1290_rep
+    .local pmc rx1290_cur
+    (rx1290_cur, rx1290_pos, rx1290_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1290_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1290_eos, rx1290_tgt
+    gt rx1290_pos, rx1290_eos, rx1290_done
+    set rx1290_off, 0
+    lt rx1290_pos, 2, rx1290_start
+    sub rx1290_off, rx1290_pos, 1
+    substr rx1290_tgt, rx1290_tgt, rx1290_off
+  rx1290_start:
+    eq $I10, 1, rx1290_restart
+    rx1290_cur."!cursor_debug"("START ", "infix:sym<,>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1294_done
+    goto rxscan1294_scan
+  rxscan1294_loop:
+    ($P10) = rx1290_cur."from"()
+    inc $P10
+    set rx1290_pos, $P10
+    ge rx1290_pos, rx1290_eos, rxscan1294_done
+  rxscan1294_scan:
+    set_addr $I10, rxscan1294_loop
+    rx1290_cur."!mark_push"(0, rx1290_pos, $I10)
+  rxscan1294_done:
 .annotate 'line', 553
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1327_fail
-    rx1322_cur."!mark_push"(0, rx1322_pos, $I10)
+    set_addr $I10, rxcap_1295_fail
+    rx1290_cur."!mark_push"(0, rx1290_pos, $I10)
   # rx literal  ","
-    add $I11, rx1322_pos, 1
-    gt $I11, rx1322_eos, rx1322_fail
-    sub $I11, rx1322_pos, rx1322_off
-    substr $S10, rx1322_tgt, $I11, 1
-    ne $S10, ",", rx1322_fail
-    add rx1322_pos, 1
-    set_addr $I10, rxcap_1327_fail
-    ($I12, $I11) = rx1322_cur."!mark_peek"($I10)
-    rx1322_cur."!cursor_pos"($I11)
-    ($P10) = rx1322_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1322_pos, "")
-    rx1322_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1290_pos, 1
+    gt $I11, rx1290_eos, rx1290_fail
+    sub $I11, rx1290_pos, rx1290_off
+    substr $S10, rx1290_tgt, $I11, 1
+    ne $S10, ",", rx1290_fail
+    add rx1290_pos, 1
+    set_addr $I10, rxcap_1295_fail
+    ($I12, $I11) = rx1290_cur."!mark_peek"($I10)
+    rx1290_cur."!cursor_pos"($I11)
+    ($P10) = rx1290_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1290_pos, "")
+    rx1290_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1327_done
-  rxcap_1327_fail:
-    goto rx1322_fail
-  rxcap_1327_done:
+    goto rxcap_1295_done
+  rxcap_1295_fail:
+    goto rx1290_fail
+  rxcap_1295_done:
   # rx subrule "O" subtype=capture negate=
-    rx1322_cur."!cursor_pos"(rx1322_pos)
-    $P10 = rx1322_cur."O"("%comma, :pasttype<list>")
-    unless $P10, rx1322_fail
-    rx1322_cur."!mark_push"(0, -1, 0, $P10)
+    rx1290_cur."!cursor_pos"(rx1290_pos)
+    $P10 = rx1290_cur."O"("%comma, :pasttype<list>")
+    unless $P10, rx1290_fail
+    rx1290_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1322_pos = $P10."pos"()
+    rx1290_pos = $P10."pos"()
   # rx pass
-    rx1322_cur."!cursor_pass"(rx1322_pos, "infix:sym<,>")
-    rx1322_cur."!cursor_debug"("PASS  ", "infix:sym<,>", " at pos=", rx1322_pos)
-    .return (rx1322_cur)
-  rx1322_fail:
+    rx1290_cur."!cursor_pass"(rx1290_pos, "infix:sym<,>")
+    rx1290_cur."!cursor_debug"("PASS  ", "infix:sym<,>", " at pos=", rx1290_pos)
+    .return (rx1290_cur)
+  rx1290_restart:
 .annotate 'line', 447
-    (rx1322_rep, rx1322_pos, $I10, $P10) = rx1322_cur."!mark_fail"(0)
-    lt rx1322_pos, -1, rx1322_done
-    eq rx1322_pos, -1, rx1322_fail
+    rx1290_cur."!cursor_debug"("NEXT ", "infix:sym<,>")
+  rx1290_fail:
+    (rx1290_rep, rx1290_pos, $I10, $P10) = rx1290_cur."!mark_fail"(0)
+    lt rx1290_pos, -1, rx1290_done
+    eq rx1290_pos, -1, rx1290_fail
     jump $I10
-  rx1322_done:
-    rx1322_cur."!cursor_fail"()
-    rx1322_cur."!cursor_debug"("FAIL  ", "infix:sym<,>")
-    .return (rx1322_cur)
+  rx1290_done:
+    rx1290_cur."!cursor_fail"()
+    rx1290_cur."!cursor_debug"("FAIL  ", "infix:sym<,>")
+    .return (rx1290_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__infix:sym<,>"  :subid("337_1278500537.15927") :method
+.sub "!PREFIX__infix:sym<,>"  :subid("337_1279529226.73787") :method
 .annotate 'line', 447
-    $P1324 = self."!PREFIX__!subrule"("O", ",")
-    new $P1325, "ResizablePMCArray"
-    push $P1325, $P1324
-    .return ($P1325)
+    $P1292 = self."!PREFIX__!subrule"("O", ",")
+    new $P1293, "ResizablePMCArray"
+    push $P1293, $P1292
+    .return ($P1293)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<return>"  :subid("338_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<return>"  :subid("338_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1329_tgt
-    .local int rx1329_pos
-    .local int rx1329_off
-    .local int rx1329_eos
-    .local int rx1329_rep
-    .local pmc rx1329_cur
-    (rx1329_cur, rx1329_pos, rx1329_tgt) = self."!cursor_start"()
-    rx1329_cur."!cursor_debug"("START ", "prefix:sym<return>")
-    .lex unicode:"$\x{a2}", rx1329_cur
+    .local string rx1297_tgt
+    .local int rx1297_pos
+    .local int rx1297_off
+    .local int rx1297_eos
+    .local int rx1297_rep
+    .local pmc rx1297_cur
+    (rx1297_cur, rx1297_pos, rx1297_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1297_cur
     .local pmc match
     .lex "$/", match
-    length rx1329_eos, rx1329_tgt
-    gt rx1329_pos, rx1329_eos, rx1329_done
-    set rx1329_off, 0
-    lt rx1329_pos, 2, rx1329_start
-    sub rx1329_off, rx1329_pos, 1
-    substr rx1329_tgt, rx1329_tgt, rx1329_off
-  rx1329_start:
+    length rx1297_eos, rx1297_tgt
+    gt rx1297_pos, rx1297_eos, rx1297_done
+    set rx1297_off, 0
+    lt rx1297_pos, 2, rx1297_start
+    sub rx1297_off, rx1297_pos, 1
+    substr rx1297_tgt, rx1297_tgt, rx1297_off
+  rx1297_start:
+    eq $I10, 1, rx1297_restart
+    rx1297_cur."!cursor_debug"("START ", "prefix:sym<return>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1332_done
-    goto rxscan1332_scan
-  rxscan1332_loop:
-    ($P10) = rx1329_cur."from"()
+    ne $I10, -1, rxscan1300_done
+    goto rxscan1300_scan
+  rxscan1300_loop:
+    ($P10) = rx1297_cur."from"()
     inc $P10
-    set rx1329_pos, $P10
-    ge rx1329_pos, rx1329_eos, rxscan1332_done
-  rxscan1332_scan:
-    set_addr $I10, rxscan1332_loop
-    rx1329_cur."!mark_push"(0, rx1329_pos, $I10)
-  rxscan1332_done:
+    set rx1297_pos, $P10
+    ge rx1297_pos, rx1297_eos, rxscan1300_done
+  rxscan1300_scan:
+    set_addr $I10, rxscan1300_loop
+    rx1297_cur."!mark_push"(0, rx1297_pos, $I10)
+  rxscan1300_done:
 .annotate 'line', 555
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1333_fail
-    rx1329_cur."!mark_push"(0, rx1329_pos, $I10)
+    set_addr $I10, rxcap_1301_fail
+    rx1297_cur."!mark_push"(0, rx1297_pos, $I10)
   # rx literal  "return"
-    add $I11, rx1329_pos, 6
-    gt $I11, rx1329_eos, rx1329_fail
-    sub $I11, rx1329_pos, rx1329_off
-    substr $S10, rx1329_tgt, $I11, 6
-    ne $S10, "return", rx1329_fail
-    add rx1329_pos, 6
-    set_addr $I10, rxcap_1333_fail
-    ($I12, $I11) = rx1329_cur."!mark_peek"($I10)
-    rx1329_cur."!cursor_pos"($I11)
-    ($P10) = rx1329_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1329_pos, "")
-    rx1329_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1297_pos, 6
+    gt $I11, rx1297_eos, rx1297_fail
+    sub $I11, rx1297_pos, rx1297_off
+    substr $S10, rx1297_tgt, $I11, 6
+    ne $S10, "return", rx1297_fail
+    add rx1297_pos, 6
+    set_addr $I10, rxcap_1301_fail
+    ($I12, $I11) = rx1297_cur."!mark_peek"($I10)
+    rx1297_cur."!cursor_pos"($I11)
+    ($P10) = rx1297_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1297_pos, "")
+    rx1297_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1333_done
-  rxcap_1333_fail:
-    goto rx1329_fail
-  rxcap_1333_done:
+    goto rxcap_1301_done
+  rxcap_1301_fail:
+    goto rx1297_fail
+  rxcap_1301_done:
   # rx charclass s
-    ge rx1329_pos, rx1329_eos, rx1329_fail
-    sub $I10, rx1329_pos, rx1329_off
-    is_cclass $I11, 32, rx1329_tgt, $I10
-    unless $I11, rx1329_fail
-    inc rx1329_pos
+    ge rx1297_pos, rx1297_eos, rx1297_fail
+    sub $I10, rx1297_pos, rx1297_off
+    is_cclass $I11, 32, rx1297_tgt, $I10
+    unless $I11, rx1297_fail
+    inc rx1297_pos
   # rx subrule "O" subtype=capture negate=
-    rx1329_cur."!cursor_pos"(rx1329_pos)
-    $P10 = rx1329_cur."O"("%list_prefix, :pasttype<return>")
-    unless $P10, rx1329_fail
-    rx1329_cur."!mark_push"(0, -1, 0, $P10)
+    rx1297_cur."!cursor_pos"(rx1297_pos)
+    $P10 = rx1297_cur."O"("%list_prefix, :pasttype<return>")
+    unless $P10, rx1297_fail
+    rx1297_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1329_pos = $P10."pos"()
+    rx1297_pos = $P10."pos"()
   # rx pass
-    rx1329_cur."!cursor_pass"(rx1329_pos, "prefix:sym<return>")
-    rx1329_cur."!cursor_debug"("PASS  ", "prefix:sym<return>", " at pos=", rx1329_pos)
-    .return (rx1329_cur)
-  rx1329_fail:
+    rx1297_cur."!cursor_pass"(rx1297_pos, "prefix:sym<return>")
+    rx1297_cur."!cursor_debug"("PASS  ", "prefix:sym<return>", " at pos=", rx1297_pos)
+    .return (rx1297_cur)
+  rx1297_restart:
 .annotate 'line', 447
-    (rx1329_rep, rx1329_pos, $I10, $P10) = rx1329_cur."!mark_fail"(0)
-    lt rx1329_pos, -1, rx1329_done
-    eq rx1329_pos, -1, rx1329_fail
+    rx1297_cur."!cursor_debug"("NEXT ", "prefix:sym<return>")
+  rx1297_fail:
+    (rx1297_rep, rx1297_pos, $I10, $P10) = rx1297_cur."!mark_fail"(0)
+    lt rx1297_pos, -1, rx1297_done
+    eq rx1297_pos, -1, rx1297_fail
     jump $I10
-  rx1329_done:
-    rx1329_cur."!cursor_fail"()
-    rx1329_cur."!cursor_debug"("FAIL  ", "prefix:sym<return>")
-    .return (rx1329_cur)
+  rx1297_done:
+    rx1297_cur."!cursor_fail"()
+    rx1297_cur."!cursor_debug"("FAIL  ", "prefix:sym<return>")
+    .return (rx1297_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<return>"  :subid("339_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<return>"  :subid("339_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1331, "ResizablePMCArray"
-    push $P1331, "return"
-    .return ($P1331)
+    new $P1299, "ResizablePMCArray"
+    push $P1299, "return"
+    .return ($P1299)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "prefix:sym<make>"  :subid("340_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "prefix:sym<make>"  :subid("340_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1335_tgt
-    .local int rx1335_pos
-    .local int rx1335_off
-    .local int rx1335_eos
-    .local int rx1335_rep
-    .local pmc rx1335_cur
-    (rx1335_cur, rx1335_pos, rx1335_tgt) = self."!cursor_start"()
-    rx1335_cur."!cursor_debug"("START ", "prefix:sym<make>")
-    .lex unicode:"$\x{a2}", rx1335_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1335_eos, rx1335_tgt
-    gt rx1335_pos, rx1335_eos, rx1335_done
-    set rx1335_off, 0
-    lt rx1335_pos, 2, rx1335_start
-    sub rx1335_off, rx1335_pos, 1
-    substr rx1335_tgt, rx1335_tgt, rx1335_off
-  rx1335_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1338_done
-    goto rxscan1338_scan
-  rxscan1338_loop:
-    ($P10) = rx1335_cur."from"()
-    inc $P10
-    set rx1335_pos, $P10
-    ge rx1335_pos, rx1335_eos, rxscan1338_done
-  rxscan1338_scan:
-    set_addr $I10, rxscan1338_loop
-    rx1335_cur."!mark_push"(0, rx1335_pos, $I10)
-  rxscan1338_done:
+    .local string rx1303_tgt
+    .local int rx1303_pos
+    .local int rx1303_off
+    .local int rx1303_eos
+    .local int rx1303_rep
+    .local pmc rx1303_cur
+    (rx1303_cur, rx1303_pos, rx1303_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1303_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1303_eos, rx1303_tgt
+    gt rx1303_pos, rx1303_eos, rx1303_done
+    set rx1303_off, 0
+    lt rx1303_pos, 2, rx1303_start
+    sub rx1303_off, rx1303_pos, 1
+    substr rx1303_tgt, rx1303_tgt, rx1303_off
+  rx1303_start:
+    eq $I10, 1, rx1303_restart
+    rx1303_cur."!cursor_debug"("START ", "prefix:sym<make>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1306_done
+    goto rxscan1306_scan
+  rxscan1306_loop:
+    ($P10) = rx1303_cur."from"()
+    inc $P10
+    set rx1303_pos, $P10
+    ge rx1303_pos, rx1303_eos, rxscan1306_done
+  rxscan1306_scan:
+    set_addr $I10, rxscan1306_loop
+    rx1303_cur."!mark_push"(0, rx1303_pos, $I10)
+  rxscan1306_done:
 .annotate 'line', 556
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1339_fail
-    rx1335_cur."!mark_push"(0, rx1335_pos, $I10)
+    set_addr $I10, rxcap_1307_fail
+    rx1303_cur."!mark_push"(0, rx1303_pos, $I10)
   # rx literal  "make"
-    add $I11, rx1335_pos, 4
-    gt $I11, rx1335_eos, rx1335_fail
-    sub $I11, rx1335_pos, rx1335_off
-    substr $S10, rx1335_tgt, $I11, 4
-    ne $S10, "make", rx1335_fail
-    add rx1335_pos, 4
-    set_addr $I10, rxcap_1339_fail
-    ($I12, $I11) = rx1335_cur."!mark_peek"($I10)
-    rx1335_cur."!cursor_pos"($I11)
-    ($P10) = rx1335_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1335_pos, "")
-    rx1335_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1303_pos, 4
+    gt $I11, rx1303_eos, rx1303_fail
+    sub $I11, rx1303_pos, rx1303_off
+    substr $S10, rx1303_tgt, $I11, 4
+    ne $S10, "make", rx1303_fail
+    add rx1303_pos, 4
+    set_addr $I10, rxcap_1307_fail
+    ($I12, $I11) = rx1303_cur."!mark_peek"($I10)
+    rx1303_cur."!cursor_pos"($I11)
+    ($P10) = rx1303_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1303_pos, "")
+    rx1303_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1339_done
-  rxcap_1339_fail:
-    goto rx1335_fail
-  rxcap_1339_done:
+    goto rxcap_1307_done
+  rxcap_1307_fail:
+    goto rx1303_fail
+  rxcap_1307_done:
   # rx charclass s
-    ge rx1335_pos, rx1335_eos, rx1335_fail
-    sub $I10, rx1335_pos, rx1335_off
-    is_cclass $I11, 32, rx1335_tgt, $I10
-    unless $I11, rx1335_fail
-    inc rx1335_pos
+    ge rx1303_pos, rx1303_eos, rx1303_fail
+    sub $I10, rx1303_pos, rx1303_off
+    is_cclass $I11, 32, rx1303_tgt, $I10
+    unless $I11, rx1303_fail
+    inc rx1303_pos
   # rx subrule "O" subtype=capture negate=
-    rx1335_cur."!cursor_pos"(rx1335_pos)
-    $P10 = rx1335_cur."O"("%list_prefix")
-    unless $P10, rx1335_fail
-    rx1335_cur."!mark_push"(0, -1, 0, $P10)
+    rx1303_cur."!cursor_pos"(rx1303_pos)
+    $P10 = rx1303_cur."O"("%list_prefix")
+    unless $P10, rx1303_fail
+    rx1303_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("O")
-    rx1335_pos = $P10."pos"()
+    rx1303_pos = $P10."pos"()
   # rx pass
-    rx1335_cur."!cursor_pass"(rx1335_pos, "prefix:sym<make>")
-    rx1335_cur."!cursor_debug"("PASS  ", "prefix:sym<make>", " at pos=", rx1335_pos)
-    .return (rx1335_cur)
-  rx1335_fail:
+    rx1303_cur."!cursor_pass"(rx1303_pos, "prefix:sym<make>")
+    rx1303_cur."!cursor_debug"("PASS  ", "prefix:sym<make>", " at pos=", rx1303_pos)
+    .return (rx1303_cur)
+  rx1303_restart:
 .annotate 'line', 447
-    (rx1335_rep, rx1335_pos, $I10, $P10) = rx1335_cur."!mark_fail"(0)
-    lt rx1335_pos, -1, rx1335_done
-    eq rx1335_pos, -1, rx1335_fail
+    rx1303_cur."!cursor_debug"("NEXT ", "prefix:sym<make>")
+  rx1303_fail:
+    (rx1303_rep, rx1303_pos, $I10, $P10) = rx1303_cur."!mark_fail"(0)
+    lt rx1303_pos, -1, rx1303_done
+    eq rx1303_pos, -1, rx1303_fail
     jump $I10
-  rx1335_done:
-    rx1335_cur."!cursor_fail"()
-    rx1335_cur."!cursor_debug"("FAIL  ", "prefix:sym<make>")
-    .return (rx1335_cur)
+  rx1303_done:
+    rx1303_cur."!cursor_fail"()
+    rx1303_cur."!cursor_debug"("FAIL  ", "prefix:sym<make>")
+    .return (rx1303_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__prefix:sym<make>"  :subid("341_1278500537.15927") :method
+.sub "!PREFIX__prefix:sym<make>"  :subid("341_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1337, "ResizablePMCArray"
-    push $P1337, "make"
-    .return ($P1337)
+    new $P1305, "ResizablePMCArray"
+    push $P1305, "make"
+    .return ($P1305)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<last>"  :subid("342_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<last>"  :subid("342_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1341_tgt
-    .local int rx1341_pos
-    .local int rx1341_off
-    .local int rx1341_eos
-    .local int rx1341_rep
-    .local pmc rx1341_cur
-    (rx1341_cur, rx1341_pos, rx1341_tgt) = self."!cursor_start"()
-    rx1341_cur."!cursor_debug"("START ", "term:sym<last>")
-    .lex unicode:"$\x{a2}", rx1341_cur
+    .local string rx1309_tgt
+    .local int rx1309_pos
+    .local int rx1309_off
+    .local int rx1309_eos
+    .local int rx1309_rep
+    .local pmc rx1309_cur
+    (rx1309_cur, rx1309_pos, rx1309_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1309_cur
     .local pmc match
     .lex "$/", match
-    length rx1341_eos, rx1341_tgt
-    gt rx1341_pos, rx1341_eos, rx1341_done
-    set rx1341_off, 0
-    lt rx1341_pos, 2, rx1341_start
-    sub rx1341_off, rx1341_pos, 1
-    substr rx1341_tgt, rx1341_tgt, rx1341_off
-  rx1341_start:
+    length rx1309_eos, rx1309_tgt
+    gt rx1309_pos, rx1309_eos, rx1309_done
+    set rx1309_off, 0
+    lt rx1309_pos, 2, rx1309_start
+    sub rx1309_off, rx1309_pos, 1
+    substr rx1309_tgt, rx1309_tgt, rx1309_off
+  rx1309_start:
+    eq $I10, 1, rx1309_restart
+    rx1309_cur."!cursor_debug"("START ", "term:sym<last>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1344_done
-    goto rxscan1344_scan
-  rxscan1344_loop:
-    ($P10) = rx1341_cur."from"()
+    ne $I10, -1, rxscan1312_done
+    goto rxscan1312_scan
+  rxscan1312_loop:
+    ($P10) = rx1309_cur."from"()
     inc $P10
-    set rx1341_pos, $P10
-    ge rx1341_pos, rx1341_eos, rxscan1344_done
-  rxscan1344_scan:
-    set_addr $I10, rxscan1344_loop
-    rx1341_cur."!mark_push"(0, rx1341_pos, $I10)
-  rxscan1344_done:
+    set rx1309_pos, $P10
+    ge rx1309_pos, rx1309_eos, rxscan1312_done
+  rxscan1312_scan:
+    set_addr $I10, rxscan1312_loop
+    rx1309_cur."!mark_push"(0, rx1309_pos, $I10)
+  rxscan1312_done:
 .annotate 'line', 557
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1345_fail
-    rx1341_cur."!mark_push"(0, rx1341_pos, $I10)
+    set_addr $I10, rxcap_1313_fail
+    rx1309_cur."!mark_push"(0, rx1309_pos, $I10)
   # rx literal  "last"
-    add $I11, rx1341_pos, 4
-    gt $I11, rx1341_eos, rx1341_fail
-    sub $I11, rx1341_pos, rx1341_off
-    substr $S10, rx1341_tgt, $I11, 4
-    ne $S10, "last", rx1341_fail
-    add rx1341_pos, 4
-    set_addr $I10, rxcap_1345_fail
-    ($I12, $I11) = rx1341_cur."!mark_peek"($I10)
-    rx1341_cur."!cursor_pos"($I11)
-    ($P10) = rx1341_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1341_pos, "")
-    rx1341_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1309_pos, 4
+    gt $I11, rx1309_eos, rx1309_fail
+    sub $I11, rx1309_pos, rx1309_off
+    substr $S10, rx1309_tgt, $I11, 4
+    ne $S10, "last", rx1309_fail
+    add rx1309_pos, 4
+    set_addr $I10, rxcap_1313_fail
+    ($I12, $I11) = rx1309_cur."!mark_peek"($I10)
+    rx1309_cur."!cursor_pos"($I11)
+    ($P10) = rx1309_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1309_pos, "")
+    rx1309_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1345_done
-  rxcap_1345_fail:
-    goto rx1341_fail
-  rxcap_1345_done:
+    goto rxcap_1313_done
+  rxcap_1313_fail:
+    goto rx1309_fail
+  rxcap_1313_done:
   # rx pass
-    rx1341_cur."!cursor_pass"(rx1341_pos, "term:sym<last>")
-    rx1341_cur."!cursor_debug"("PASS  ", "term:sym<last>", " at pos=", rx1341_pos)
-    .return (rx1341_cur)
-  rx1341_fail:
+    rx1309_cur."!cursor_pass"(rx1309_pos, "term:sym<last>")
+    rx1309_cur."!cursor_debug"("PASS  ", "term:sym<last>", " at pos=", rx1309_pos)
+    .return (rx1309_cur)
+  rx1309_restart:
 .annotate 'line', 447
-    (rx1341_rep, rx1341_pos, $I10, $P10) = rx1341_cur."!mark_fail"(0)
-    lt rx1341_pos, -1, rx1341_done
-    eq rx1341_pos, -1, rx1341_fail
+    rx1309_cur."!cursor_debug"("NEXT ", "term:sym<last>")
+  rx1309_fail:
+    (rx1309_rep, rx1309_pos, $I10, $P10) = rx1309_cur."!mark_fail"(0)
+    lt rx1309_pos, -1, rx1309_done
+    eq rx1309_pos, -1, rx1309_fail
     jump $I10
-  rx1341_done:
-    rx1341_cur."!cursor_fail"()
-    rx1341_cur."!cursor_debug"("FAIL  ", "term:sym<last>")
-    .return (rx1341_cur)
+  rx1309_done:
+    rx1309_cur."!cursor_fail"()
+    rx1309_cur."!cursor_debug"("FAIL  ", "term:sym<last>")
+    .return (rx1309_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<last>"  :subid("343_1278500537.15927") :method
+.sub "!PREFIX__term:sym<last>"  :subid("343_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1343, "ResizablePMCArray"
-    push $P1343, "last"
-    .return ($P1343)
+    new $P1311, "ResizablePMCArray"
+    push $P1311, "last"
+    .return ($P1311)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<next>"  :subid("344_1278500537.15927") :method :outer("11_1278500537.15927")
+.sub "term:sym<next>"  :subid("344_1279529226.73787") :method :outer("11_1279529226.73787")
 .annotate 'line', 447
-    .local string rx1347_tgt
-    .local int rx1347_pos
-    .local int rx1347_off
-    .local int rx1347_eos
-    .local int rx1347_rep
-    .local pmc rx1347_cur
-    (rx1347_cur, rx1347_pos, rx1347_tgt) = self."!cursor_start"()
-    rx1347_cur."!cursor_debug"("START ", "term:sym<next>")
-    .lex unicode:"$\x{a2}", rx1347_cur
+    .local string rx1315_tgt
+    .local int rx1315_pos
+    .local int rx1315_off
+    .local int rx1315_eos
+    .local int rx1315_rep
+    .local pmc rx1315_cur
+    (rx1315_cur, rx1315_pos, rx1315_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1315_cur
     .local pmc match
     .lex "$/", match
-    length rx1347_eos, rx1347_tgt
-    gt rx1347_pos, rx1347_eos, rx1347_done
-    set rx1347_off, 0
-    lt rx1347_pos, 2, rx1347_start
-    sub rx1347_off, rx1347_pos, 1
-    substr rx1347_tgt, rx1347_tgt, rx1347_off
-  rx1347_start:
+    length rx1315_eos, rx1315_tgt
+    gt rx1315_pos, rx1315_eos, rx1315_done
+    set rx1315_off, 0
+    lt rx1315_pos, 2, rx1315_start
+    sub rx1315_off, rx1315_pos, 1
+    substr rx1315_tgt, rx1315_tgt, rx1315_off
+  rx1315_start:
+    eq $I10, 1, rx1315_restart
+    rx1315_cur."!cursor_debug"("START ", "term:sym<next>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan1350_done
-    goto rxscan1350_scan
-  rxscan1350_loop:
-    ($P10) = rx1347_cur."from"()
+    ne $I10, -1, rxscan1318_done
+    goto rxscan1318_scan
+  rxscan1318_loop:
+    ($P10) = rx1315_cur."from"()
     inc $P10
-    set rx1347_pos, $P10
-    ge rx1347_pos, rx1347_eos, rxscan1350_done
-  rxscan1350_scan:
-    set_addr $I10, rxscan1350_loop
-    rx1347_cur."!mark_push"(0, rx1347_pos, $I10)
-  rxscan1350_done:
+    set rx1315_pos, $P10
+    ge rx1315_pos, rx1315_eos, rxscan1318_done
+  rxscan1318_scan:
+    set_addr $I10, rxscan1318_loop
+    rx1315_cur."!mark_push"(0, rx1315_pos, $I10)
+  rxscan1318_done:
 .annotate 'line', 558
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1351_fail
-    rx1347_cur."!mark_push"(0, rx1347_pos, $I10)
+    set_addr $I10, rxcap_1319_fail
+    rx1315_cur."!mark_push"(0, rx1315_pos, $I10)
   # rx literal  "next"
-    add $I11, rx1347_pos, 4
-    gt $I11, rx1347_eos, rx1347_fail
-    sub $I11, rx1347_pos, rx1347_off
-    substr $S10, rx1347_tgt, $I11, 4
-    ne $S10, "next", rx1347_fail
-    add rx1347_pos, 4
-    set_addr $I10, rxcap_1351_fail
-    ($I12, $I11) = rx1347_cur."!mark_peek"($I10)
-    rx1347_cur."!cursor_pos"($I11)
-    ($P10) = rx1347_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1347_pos, "")
-    rx1347_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1315_pos, 4
+    gt $I11, rx1315_eos, rx1315_fail
+    sub $I11, rx1315_pos, rx1315_off
+    substr $S10, rx1315_tgt, $I11, 4
+    ne $S10, "next", rx1315_fail
+    add rx1315_pos, 4
+    set_addr $I10, rxcap_1319_fail
+    ($I12, $I11) = rx1315_cur."!mark_peek"($I10)
+    rx1315_cur."!cursor_pos"($I11)
+    ($P10) = rx1315_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1315_pos, "")
+    rx1315_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1351_done
-  rxcap_1351_fail:
-    goto rx1347_fail
-  rxcap_1351_done:
+    goto rxcap_1319_done
+  rxcap_1319_fail:
+    goto rx1315_fail
+  rxcap_1319_done:
   # rx pass
-    rx1347_cur."!cursor_pass"(rx1347_pos, "term:sym<next>")
-    rx1347_cur."!cursor_debug"("PASS  ", "term:sym<next>", " at pos=", rx1347_pos)
-    .return (rx1347_cur)
-  rx1347_fail:
+    rx1315_cur."!cursor_pass"(rx1315_pos, "term:sym<next>")
+    rx1315_cur."!cursor_debug"("PASS  ", "term:sym<next>", " at pos=", rx1315_pos)
+    .return (rx1315_cur)
+  rx1315_restart:
 .annotate 'line', 447
-    (rx1347_rep, rx1347_pos, $I10, $P10) = rx1347_cur."!mark_fail"(0)
-    lt rx1347_pos, -1, rx1347_done
-    eq rx1347_pos, -1, rx1347_fail
+    rx1315_cur."!cursor_debug"("NEXT ", "term:sym<next>")
+  rx1315_fail:
+    (rx1315_rep, rx1315_pos, $I10, $P10) = rx1315_cur."!mark_fail"(0)
+    lt rx1315_pos, -1, rx1315_done
+    eq rx1315_pos, -1, rx1315_fail
     jump $I10
-  rx1347_done:
-    rx1347_cur."!cursor_fail"()
-    rx1347_cur."!cursor_debug"("FAIL  ", "term:sym<next>")
-    .return (rx1347_cur)
+  rx1315_done:
+    rx1315_cur."!cursor_fail"()
+    rx1315_cur."!cursor_debug"("FAIL  ", "term:sym<next>")
+    .return (rx1315_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<next>"  :subid("345_1278500537.15927") :method
+.sub "!PREFIX__term:sym<next>"  :subid("345_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1349, "ResizablePMCArray"
-    push $P1349, "next"
-    .return ($P1349)
+    new $P1317, "ResizablePMCArray"
+    push $P1317, "next"
+    .return ($P1317)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "term:sym<redo>"  :subid("346_1278500537.15927") :method :outer("11_1278500537.15927")
-.annotate 'line', 447
-    .local string rx1353_tgt
-    .local int rx1353_pos
-    .local int rx1353_off
-    .local int rx1353_eos
-    .local int rx1353_rep
-    .local pmc rx1353_cur
-    (rx1353_cur, rx1353_pos, rx1353_tgt) = self."!cursor_start"()
-    rx1353_cur."!cursor_debug"("START ", "term:sym<redo>")
-    .lex unicode:"$\x{a2}", rx1353_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1353_eos, rx1353_tgt
-    gt rx1353_pos, rx1353_eos, rx1353_done
-    set rx1353_off, 0
-    lt rx1353_pos, 2, rx1353_start
-    sub rx1353_off, rx1353_pos, 1
-    substr rx1353_tgt, rx1353_tgt, rx1353_off
-  rx1353_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1356_done
-    goto rxscan1356_scan
-  rxscan1356_loop:
-    ($P10) = rx1353_cur."from"()
-    inc $P10
-    set rx1353_pos, $P10
-    ge rx1353_pos, rx1353_eos, rxscan1356_done
-  rxscan1356_scan:
-    set_addr $I10, rxscan1356_loop
-    rx1353_cur."!mark_push"(0, rx1353_pos, $I10)
-  rxscan1356_done:
+.sub "term:sym<redo>"  :subid("346_1279529226.73787") :method :outer("11_1279529226.73787")
+.annotate 'line', 447
+    .local string rx1321_tgt
+    .local int rx1321_pos
+    .local int rx1321_off
+    .local int rx1321_eos
+    .local int rx1321_rep
+    .local pmc rx1321_cur
+    (rx1321_cur, rx1321_pos, rx1321_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1321_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1321_eos, rx1321_tgt
+    gt rx1321_pos, rx1321_eos, rx1321_done
+    set rx1321_off, 0
+    lt rx1321_pos, 2, rx1321_start
+    sub rx1321_off, rx1321_pos, 1
+    substr rx1321_tgt, rx1321_tgt, rx1321_off
+  rx1321_start:
+    eq $I10, 1, rx1321_restart
+    rx1321_cur."!cursor_debug"("START ", "term:sym<redo>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1324_done
+    goto rxscan1324_scan
+  rxscan1324_loop:
+    ($P10) = rx1321_cur."from"()
+    inc $P10
+    set rx1321_pos, $P10
+    ge rx1321_pos, rx1321_eos, rxscan1324_done
+  rxscan1324_scan:
+    set_addr $I10, rxscan1324_loop
+    rx1321_cur."!mark_push"(0, rx1321_pos, $I10)
+  rxscan1324_done:
 .annotate 'line', 559
   # rx subcapture "sym"
-    set_addr $I10, rxcap_1357_fail
-    rx1353_cur."!mark_push"(0, rx1353_pos, $I10)
+    set_addr $I10, rxcap_1325_fail
+    rx1321_cur."!mark_push"(0, rx1321_pos, $I10)
   # rx literal  "redo"
-    add $I11, rx1353_pos, 4
-    gt $I11, rx1353_eos, rx1353_fail
-    sub $I11, rx1353_pos, rx1353_off
-    substr $S10, rx1353_tgt, $I11, 4
-    ne $S10, "redo", rx1353_fail
-    add rx1353_pos, 4
-    set_addr $I10, rxcap_1357_fail
-    ($I12, $I11) = rx1353_cur."!mark_peek"($I10)
-    rx1353_cur."!cursor_pos"($I11)
-    ($P10) = rx1353_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1353_pos, "")
-    rx1353_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx1321_pos, 4
+    gt $I11, rx1321_eos, rx1321_fail
+    sub $I11, rx1321_pos, rx1321_off
+    substr $S10, rx1321_tgt, $I11, 4
+    ne $S10, "redo", rx1321_fail
+    add rx1321_pos, 4
+    set_addr $I10, rxcap_1325_fail
+    ($I12, $I11) = rx1321_cur."!mark_peek"($I10)
+    rx1321_cur."!cursor_pos"($I11)
+    ($P10) = rx1321_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1321_pos, "")
+    rx1321_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_1357_done
-  rxcap_1357_fail:
-    goto rx1353_fail
-  rxcap_1357_done:
+    goto rxcap_1325_done
+  rxcap_1325_fail:
+    goto rx1321_fail
+  rxcap_1325_done:
   # rx pass
-    rx1353_cur."!cursor_pass"(rx1353_pos, "term:sym<redo>")
-    rx1353_cur."!cursor_debug"("PASS  ", "term:sym<redo>", " at pos=", rx1353_pos)
-    .return (rx1353_cur)
-  rx1353_fail:
+    rx1321_cur."!cursor_pass"(rx1321_pos, "term:sym<redo>")
+    rx1321_cur."!cursor_debug"("PASS  ", "term:sym<redo>", " at pos=", rx1321_pos)
+    .return (rx1321_cur)
+  rx1321_restart:
 .annotate 'line', 447
-    (rx1353_rep, rx1353_pos, $I10, $P10) = rx1353_cur."!mark_fail"(0)
-    lt rx1353_pos, -1, rx1353_done
-    eq rx1353_pos, -1, rx1353_fail
+    rx1321_cur."!cursor_debug"("NEXT ", "term:sym<redo>")
+  rx1321_fail:
+    (rx1321_rep, rx1321_pos, $I10, $P10) = rx1321_cur."!mark_fail"(0)
+    lt rx1321_pos, -1, rx1321_done
+    eq rx1321_pos, -1, rx1321_fail
     jump $I10
-  rx1353_done:
-    rx1353_cur."!cursor_fail"()
-    rx1353_cur."!cursor_debug"("FAIL  ", "term:sym<redo>")
-    .return (rx1353_cur)
+  rx1321_done:
+    rx1321_cur."!cursor_fail"()
+    rx1321_cur."!cursor_debug"("FAIL  ", "term:sym<redo>")
+    .return (rx1321_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "!PREFIX__term:sym<redo>"  :subid("347_1278500537.15927") :method
+.sub "!PREFIX__term:sym<redo>"  :subid("347_1279529226.73787") :method
 .annotate 'line', 447
-    new $P1355, "ResizablePMCArray"
-    push $P1355, "redo"
-    .return ($P1355)
+    new $P1323, "ResizablePMCArray"
+    push $P1323, "redo"
+    .return ($P1323)
 .end
 
 
 .namespace ["NQP";"Grammar"]
 .include "except_types.pasm"
-.sub "smartmatch"  :subid("348_1278500537.15927") :method :outer("11_1278500537.15927")
-    .param pmc param_1361
+.sub "smartmatch"  :subid("348_1279529226.73787") :method :outer("11_1279529226.73787")
+    .param pmc param_1329
 .annotate 'line', 561
-    new $P1360, 'ExceptionHandler'
-    set_addr $P1360, control_1359
-    $P1360."handle_types"(.CONTROL_RETURN)
-    push_eh $P1360
+    new $P1328, 'ExceptionHandler'
+    set_addr $P1328, control_1327
+    $P1328."handle_types"(.CONTROL_RETURN)
+    push_eh $P1328
     .lex "self", self
-    .lex "$/", param_1361
+    .lex "$/", param_1329
 .annotate 'line', 563
-    new $P1362, "Undef"
-    .lex "$t", $P1362
-    find_lex $P1363, "$/"
-    unless_null $P1363, vivify_384
-    $P1363 = root_new ['parrot';'ResizablePMCArray']
+    new $P1330, "Undef"
+    .lex "$t", $P1330
+    find_lex $P1331, "$/"
+    unless_null $P1331, vivify_384
+    $P1331 = root_new ['parrot';'ResizablePMCArray']
   vivify_384:
-    set $P1364, $P1363[0]
-    unless_null $P1364, vivify_385
-    new $P1364, "Undef"
+    set $P1332, $P1331[0]
+    unless_null $P1332, vivify_385
+    new $P1332, "Undef"
   vivify_385:
-    store_lex "$t", $P1364
-    find_lex $P1365, "$/"
-    unless_null $P1365, vivify_386
-    $P1365 = root_new ['parrot';'ResizablePMCArray']
+    store_lex "$t", $P1332
+    find_lex $P1333, "$/"
+    unless_null $P1333, vivify_386
+    $P1333 = root_new ['parrot';'ResizablePMCArray']
   vivify_386:
-    set $P1366, $P1365[1]
-    unless_null $P1366, vivify_387
-    new $P1366, "Undef"
+    set $P1334, $P1333[1]
+    unless_null $P1334, vivify_387
+    new $P1334, "Undef"
   vivify_387:
-    find_lex $P1367, "$/"
-    unless_null $P1367, vivify_388
-    $P1367 = root_new ['parrot';'ResizablePMCArray']
-    store_lex "$/", $P1367
+    find_lex $P1335, "$/"
+    unless_null $P1335, vivify_388
+    $P1335 = root_new ['parrot';'ResizablePMCArray']
+    store_lex "$/", $P1335
   vivify_388:
-    set $P1367[0], $P1366
-    find_lex $P1368, "$t"
-    find_lex $P1369, "$/"
-    unless_null $P1369, vivify_389
-    $P1369 = root_new ['parrot';'ResizablePMCArray']
-    store_lex "$/", $P1369
+    set $P1335[0], $P1334
+    find_lex $P1336, "$t"
+    find_lex $P1337, "$/"
+    unless_null $P1337, vivify_389
+    $P1337 = root_new ['parrot';'ResizablePMCArray']
+    store_lex "$/", $P1337
   vivify_389:
-    set $P1369[1], $P1368
+    set $P1337[1], $P1336
 .annotate 'line', 561
-    .return ($P1368)
-  control_1359:
+    .return ($P1336)
+  control_1327:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1370, exception, "payload"
-    .return ($P1370)
+    getattribute $P1338, exception, "payload"
+    .return ($P1338)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "_block1371"  :subid("349_1278500537.15927") :outer("11_1278500537.15927")
+.sub "_block1339"  :subid("349_1279529226.73787") :outer("11_1279529226.73787")
 .annotate 'line', 567
-    .const 'Sub' $P1429 = "368_1278500537.15927" 
-    capture_lex $P1429
-    .const 'Sub' $P1424 = "366_1278500537.15927" 
-    capture_lex $P1424
-    .const 'Sub' $P1411 = "363_1278500537.15927" 
-    capture_lex $P1411
-    .const 'Sub' $P1401 = "360_1278500537.15927" 
-    capture_lex $P1401
-    .const 'Sub' $P1396 = "358_1278500537.15927" 
+    .const 'Sub' $P1396 = "368_1279529226.73787" 
+    capture_lex $P1396
+    .const 'Sub' $P1391 = "366_1279529226.73787" 
+    capture_lex $P1391
+    .const 'Sub' $P1379 = "363_1279529226.73787" 
+    capture_lex $P1379
+    .const 'Sub' $P1369 = "360_1279529226.73787" 
+    capture_lex $P1369
+    .const 'Sub' $P1364 = "358_1279529226.73787" 
+    capture_lex $P1364
+    .const 'Sub' $P1355 = "355_1279529226.73787" 
+    capture_lex $P1355
+    .const 'Sub' $P1350 = "353_1279529226.73787" 
+    capture_lex $P1350
+    .const 'Sub' $P1341 = "350_1279529226.73787" 
+    capture_lex $P1341
+    .const 'Sub' $P1396 = "368_1279529226.73787" 
     capture_lex $P1396
-    .const 'Sub' $P1387 = "355_1278500537.15927" 
-    capture_lex $P1387
-    .const 'Sub' $P1382 = "353_1278500537.15927" 
-    capture_lex $P1382
-    .const 'Sub' $P1373 = "350_1278500537.15927" 
-    capture_lex $P1373
-    .const 'Sub' $P1429 = "368_1278500537.15927" 
-    capture_lex $P1429
-    .return ($P1429)
+    .return ($P1396)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "metachar:sym<:my>"  :subid("350_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "metachar:sym<:my>"  :subid("350_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .const 'Sub' $P1379 = "352_1278500537.15927" 
-    capture_lex $P1379
-    .local string rx1374_tgt
-    .local int rx1374_pos
-    .local int rx1374_off
-    .local int rx1374_eos
-    .local int rx1374_rep
-    .local pmc rx1374_cur
-    (rx1374_cur, rx1374_pos, rx1374_tgt) = self."!cursor_start"()
-    rx1374_cur."!cursor_debug"("START ", "metachar:sym<:my>")
-    .lex unicode:"$\x{a2}", rx1374_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1374_eos, rx1374_tgt
-    gt rx1374_pos, rx1374_eos, rx1374_done
-    set rx1374_off, 0
-    lt rx1374_pos, 2, rx1374_start
-    sub rx1374_off, rx1374_pos, 1
-    substr rx1374_tgt, rx1374_tgt, rx1374_off
-  rx1374_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1377_done
-    goto rxscan1377_scan
-  rxscan1377_loop:
-    ($P10) = rx1374_cur."from"()
-    inc $P10
-    set rx1374_pos, $P10
-    ge rx1374_pos, rx1374_eos, rxscan1377_done
-  rxscan1377_scan:
-    set_addr $I10, rxscan1377_loop
-    rx1374_cur."!mark_push"(0, rx1374_pos, $I10)
-  rxscan1377_done:
+    .const 'Sub' $P1347 = "352_1279529226.73787" 
+    capture_lex $P1347
+    .local string rx1342_tgt
+    .local int rx1342_pos
+    .local int rx1342_off
+    .local int rx1342_eos
+    .local int rx1342_rep
+    .local pmc rx1342_cur
+    (rx1342_cur, rx1342_pos, rx1342_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1342_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1342_eos, rx1342_tgt
+    gt rx1342_pos, rx1342_eos, rx1342_done
+    set rx1342_off, 0
+    lt rx1342_pos, 2, rx1342_start
+    sub rx1342_off, rx1342_pos, 1
+    substr rx1342_tgt, rx1342_tgt, rx1342_off
+  rx1342_start:
+    eq $I10, 1, rx1342_restart
+    rx1342_cur."!cursor_debug"("START ", "metachar:sym<:my>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1345_done
+    goto rxscan1345_scan
+  rxscan1345_loop:
+    ($P10) = rx1342_cur."from"()
+    inc $P10
+    set rx1342_pos, $P10
+    ge rx1342_pos, rx1342_eos, rxscan1345_done
+  rxscan1345_scan:
+    set_addr $I10, rxscan1345_loop
+    rx1342_cur."!mark_push"(0, rx1342_pos, $I10)
+  rxscan1345_done:
 .annotate 'line', 569
   # rx literal  ":"
-    add $I11, rx1374_pos, 1
-    gt $I11, rx1374_eos, rx1374_fail
-    sub $I11, rx1374_pos, rx1374_off
-    substr $S10, rx1374_tgt, $I11, 1
-    ne $S10, ":", rx1374_fail
-    add rx1374_pos, 1
+    add $I11, rx1342_pos, 1
+    gt $I11, rx1342_eos, rx1342_fail
+    sub $I11, rx1342_pos, rx1342_off
+    substr $S10, rx1342_tgt, $I11, 1
+    ne $S10, ":", rx1342_fail
+    add rx1342_pos, 1
   # rx subrule "before" subtype=zerowidth negate=
-    rx1374_cur."!cursor_pos"(rx1374_pos)
-    .const 'Sub' $P1379 = "352_1278500537.15927" 
-    capture_lex $P1379
-    $P10 = rx1374_cur."before"($P1379)
-    unless $P10, rx1374_fail
+    rx1342_cur."!cursor_pos"(rx1342_pos)
+    .const 'Sub' $P1347 = "352_1279529226.73787" 
+    capture_lex $P1347
+    $P10 = rx1342_cur."before"($P1347)
+    unless $P10, rx1342_fail
   # rx subrule "LANG" subtype=capture negate=
-    rx1374_cur."!cursor_pos"(rx1374_pos)
-    $P10 = rx1374_cur."LANG"("MAIN", "statement")
-    unless $P10, rx1374_fail
-    rx1374_cur."!mark_push"(0, -1, 0, $P10)
+    rx1342_cur."!cursor_pos"(rx1342_pos)
+    $P10 = rx1342_cur."LANG"("MAIN", "statement")
+    unless $P10, rx1342_fail
+    rx1342_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("statement")
-    rx1374_pos = $P10."pos"()
+    rx1342_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx1374_cur."!cursor_pos"(rx1374_pos)
-    $P10 = rx1374_cur."ws"()
-    unless $P10, rx1374_fail
-    rx1374_pos = $P10."pos"()
+    rx1342_cur."!cursor_pos"(rx1342_pos)
+    $P10 = rx1342_cur."ws"()
+    unless $P10, rx1342_fail
+    rx1342_pos = $P10."pos"()
   # rx literal  ";"
-    add $I11, rx1374_pos, 1
-    gt $I11, rx1374_eos, rx1374_fail
-    sub $I11, rx1374_pos, rx1374_off
-    substr $S10, rx1374_tgt, $I11, 1
-    ne $S10, ";", rx1374_fail
-    add rx1374_pos, 1
+    add $I11, rx1342_pos, 1
+    gt $I11, rx1342_eos, rx1342_fail
+    sub $I11, rx1342_pos, rx1342_off
+    substr $S10, rx1342_tgt, $I11, 1
+    ne $S10, ";", rx1342_fail
+    add rx1342_pos, 1
 .annotate 'line', 568
   # rx pass
-    rx1374_cur."!cursor_pass"(rx1374_pos, "metachar:sym<:my>")
-    rx1374_cur."!cursor_debug"("PASS  ", "metachar:sym<:my>", " at pos=", rx1374_pos)
-    .return (rx1374_cur)
-  rx1374_fail:
+    rx1342_cur."!cursor_pass"(rx1342_pos, "metachar:sym<:my>")
+    rx1342_cur."!cursor_debug"("PASS  ", "metachar:sym<:my>", " at pos=", rx1342_pos)
+    .return (rx1342_cur)
+  rx1342_restart:
 .annotate 'line', 567
-    (rx1374_rep, rx1374_pos, $I10, $P10) = rx1374_cur."!mark_fail"(0)
-    lt rx1374_pos, -1, rx1374_done
-    eq rx1374_pos, -1, rx1374_fail
-    jump $I10
-  rx1374_done:
-    rx1374_cur."!cursor_fail"()
-    rx1374_cur."!cursor_debug"("FAIL  ", "metachar:sym<:my>")
-    .return (rx1374_cur)
+    rx1342_cur."!cursor_debug"("NEXT ", "metachar:sym<:my>")
+  rx1342_fail:
+    (rx1342_rep, rx1342_pos, $I10, $P10) = rx1342_cur."!mark_fail"(0)
+    lt rx1342_pos, -1, rx1342_done
+    eq rx1342_pos, -1, rx1342_fail
+    jump $I10
+  rx1342_done:
+    rx1342_cur."!cursor_fail"()
+    rx1342_cur."!cursor_debug"("FAIL  ", "metachar:sym<:my>")
+    .return (rx1342_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__metachar:sym<:my>"  :subid("351_1278500537.15927") :method
+.sub "!PREFIX__metachar:sym<:my>"  :subid("351_1279529226.73787") :method
 .annotate 'line', 567
-    new $P1376, "ResizablePMCArray"
-    push $P1376, ":"
-    .return ($P1376)
+    new $P1344, "ResizablePMCArray"
+    push $P1344, ":"
+    .return ($P1344)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "_block1378"  :anon :subid("352_1278500537.15927") :method :outer("350_1278500537.15927")
+.sub "_block1346"  :anon :subid("352_1279529226.73787") :method :outer("350_1279529226.73787")
 .annotate 'line', 569
-    .local string rx1380_tgt
-    .local int rx1380_pos
-    .local int rx1380_off
-    .local int rx1380_eos
-    .local int rx1380_rep
-    .local pmc rx1380_cur
-    (rx1380_cur, rx1380_pos, rx1380_tgt) = self."!cursor_start"()
-    rx1380_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx1380_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1380_eos, rx1380_tgt
-    gt rx1380_pos, rx1380_eos, rx1380_done
-    set rx1380_off, 0
-    lt rx1380_pos, 2, rx1380_start
-    sub rx1380_off, rx1380_pos, 1
-    substr rx1380_tgt, rx1380_tgt, rx1380_off
-  rx1380_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1381_done
-    goto rxscan1381_scan
-  rxscan1381_loop:
-    ($P10) = rx1380_cur."from"()
-    inc $P10
-    set rx1380_pos, $P10
-    ge rx1380_pos, rx1380_eos, rxscan1381_done
-  rxscan1381_scan:
-    set_addr $I10, rxscan1381_loop
-    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
-  rxscan1381_done:
+    .local string rx1348_tgt
+    .local int rx1348_pos
+    .local int rx1348_off
+    .local int rx1348_eos
+    .local int rx1348_rep
+    .local pmc rx1348_cur
+    (rx1348_cur, rx1348_pos, rx1348_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1348_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1348_eos, rx1348_tgt
+    gt rx1348_pos, rx1348_eos, rx1348_done
+    set rx1348_off, 0
+    lt rx1348_pos, 2, rx1348_start
+    sub rx1348_off, rx1348_pos, 1
+    substr rx1348_tgt, rx1348_tgt, rx1348_off
+  rx1348_start:
+    eq $I10, 1, rx1348_restart
+    rx1348_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1349_done
+    goto rxscan1349_scan
+  rxscan1349_loop:
+    ($P10) = rx1348_cur."from"()
+    inc $P10
+    set rx1348_pos, $P10
+    ge rx1348_pos, rx1348_eos, rxscan1349_done
+  rxscan1349_scan:
+    set_addr $I10, rxscan1349_loop
+    rx1348_cur."!mark_push"(0, rx1348_pos, $I10)
+  rxscan1349_done:
   # rx literal  "my"
-    add $I11, rx1380_pos, 2
-    gt $I11, rx1380_eos, rx1380_fail
-    sub $I11, rx1380_pos, rx1380_off
-    substr $S10, rx1380_tgt, $I11, 2
-    ne $S10, "my", rx1380_fail
-    add rx1380_pos, 2
-  # rx pass
-    rx1380_cur."!cursor_pass"(rx1380_pos, "")
-    rx1380_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1380_pos)
-    .return (rx1380_cur)
-  rx1380_fail:
-    (rx1380_rep, rx1380_pos, $I10, $P10) = rx1380_cur."!mark_fail"(0)
-    lt rx1380_pos, -1, rx1380_done
-    eq rx1380_pos, -1, rx1380_fail
-    jump $I10
-  rx1380_done:
-    rx1380_cur."!cursor_fail"()
-    rx1380_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx1380_cur)
+    add $I11, rx1348_pos, 2
+    gt $I11, rx1348_eos, rx1348_fail
+    sub $I11, rx1348_pos, rx1348_off
+    substr $S10, rx1348_tgt, $I11, 2
+    ne $S10, "my", rx1348_fail
+    add rx1348_pos, 2
+  # rx pass
+    rx1348_cur."!cursor_pass"(rx1348_pos, "")
+    rx1348_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1348_pos)
+    .return (rx1348_cur)
+  rx1348_restart:
+    rx1348_cur."!cursor_debug"("NEXT ", "")
+  rx1348_fail:
+    (rx1348_rep, rx1348_pos, $I10, $P10) = rx1348_cur."!mark_fail"(0)
+    lt rx1348_pos, -1, rx1348_done
+    eq rx1348_pos, -1, rx1348_fail
+    jump $I10
+  rx1348_done:
+    rx1348_cur."!cursor_fail"()
+    rx1348_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx1348_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "metachar:sym<{ }>"  :subid("353_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "metachar:sym<{ }>"  :subid("353_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .local string rx1383_tgt
-    .local int rx1383_pos
-    .local int rx1383_off
-    .local int rx1383_eos
-    .local int rx1383_rep
-    .local pmc rx1383_cur
-    (rx1383_cur, rx1383_pos, rx1383_tgt) = self."!cursor_start"()
-    rx1383_cur."!cursor_debug"("START ", "metachar:sym<{ }>")
-    .lex unicode:"$\x{a2}", rx1383_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1383_eos, rx1383_tgt
-    gt rx1383_pos, rx1383_eos, rx1383_done
-    set rx1383_off, 0
-    lt rx1383_pos, 2, rx1383_start
-    sub rx1383_off, rx1383_pos, 1
-    substr rx1383_tgt, rx1383_tgt, rx1383_off
-  rx1383_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1386_done
-    goto rxscan1386_scan
-  rxscan1386_loop:
-    ($P10) = rx1383_cur."from"()
-    inc $P10
-    set rx1383_pos, $P10
-    ge rx1383_pos, rx1383_eos, rxscan1386_done
-  rxscan1386_scan:
-    set_addr $I10, rxscan1386_loop
-    rx1383_cur."!mark_push"(0, rx1383_pos, $I10)
-  rxscan1386_done:
+    .local string rx1351_tgt
+    .local int rx1351_pos
+    .local int rx1351_off
+    .local int rx1351_eos
+    .local int rx1351_rep
+    .local pmc rx1351_cur
+    (rx1351_cur, rx1351_pos, rx1351_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1351_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1351_eos, rx1351_tgt
+    gt rx1351_pos, rx1351_eos, rx1351_done
+    set rx1351_off, 0
+    lt rx1351_pos, 2, rx1351_start
+    sub rx1351_off, rx1351_pos, 1
+    substr rx1351_tgt, rx1351_tgt, rx1351_off
+  rx1351_start:
+    eq $I10, 1, rx1351_restart
+    rx1351_cur."!cursor_debug"("START ", "metachar:sym<{ }>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1354_done
+    goto rxscan1354_scan
+  rxscan1354_loop:
+    ($P10) = rx1351_cur."from"()
+    inc $P10
+    set rx1351_pos, $P10
+    ge rx1351_pos, rx1351_eos, rxscan1354_done
+  rxscan1354_scan:
+    set_addr $I10, rxscan1354_loop
+    rx1351_cur."!mark_push"(0, rx1351_pos, $I10)
+  rxscan1354_done:
 .annotate 'line', 573
   # rx enumcharlist negate=0 zerowidth
-    ge rx1383_pos, rx1383_eos, rx1383_fail
-    sub $I10, rx1383_pos, rx1383_off
-    substr $S10, rx1383_tgt, $I10, 1
+    ge rx1351_pos, rx1351_eos, rx1351_fail
+    sub $I10, rx1351_pos, rx1351_off
+    substr $S10, rx1351_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx1383_fail
+    lt $I11, 0, rx1351_fail
   # rx subrule "codeblock" subtype=capture negate=
-    rx1383_cur."!cursor_pos"(rx1383_pos)
-    $P10 = rx1383_cur."codeblock"()
-    unless $P10, rx1383_fail
-    rx1383_cur."!mark_push"(0, -1, 0, $P10)
+    rx1351_cur."!cursor_pos"(rx1351_pos)
+    $P10 = rx1351_cur."codeblock"()
+    unless $P10, rx1351_fail
+    rx1351_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("codeblock")
-    rx1383_pos = $P10."pos"()
+    rx1351_pos = $P10."pos"()
 .annotate 'line', 572
   # rx pass
-    rx1383_cur."!cursor_pass"(rx1383_pos, "metachar:sym<{ }>")
-    rx1383_cur."!cursor_debug"("PASS  ", "metachar:sym<{ }>", " at pos=", rx1383_pos)
-    .return (rx1383_cur)
-  rx1383_fail:
+    rx1351_cur."!cursor_pass"(rx1351_pos, "metachar:sym<{ }>")
+    rx1351_cur."!cursor_debug"("PASS  ", "metachar:sym<{ }>", " at pos=", rx1351_pos)
+    .return (rx1351_cur)
+  rx1351_restart:
 .annotate 'line', 567
-    (rx1383_rep, rx1383_pos, $I10, $P10) = rx1383_cur."!mark_fail"(0)
-    lt rx1383_pos, -1, rx1383_done
-    eq rx1383_pos, -1, rx1383_fail
-    jump $I10
-  rx1383_done:
-    rx1383_cur."!cursor_fail"()
-    rx1383_cur."!cursor_debug"("FAIL  ", "metachar:sym<{ }>")
-    .return (rx1383_cur)
+    rx1351_cur."!cursor_debug"("NEXT ", "metachar:sym<{ }>")
+  rx1351_fail:
+    (rx1351_rep, rx1351_pos, $I10, $P10) = rx1351_cur."!mark_fail"(0)
+    lt rx1351_pos, -1, rx1351_done
+    eq rx1351_pos, -1, rx1351_fail
+    jump $I10
+  rx1351_done:
+    rx1351_cur."!cursor_fail"()
+    rx1351_cur."!cursor_debug"("FAIL  ", "metachar:sym<{ }>")
+    .return (rx1351_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__metachar:sym<{ }>"  :subid("354_1278500537.15927") :method
+.sub "!PREFIX__metachar:sym<{ }>"  :subid("354_1279529226.73787") :method
 .annotate 'line', 567
-    new $P1385, "ResizablePMCArray"
-    push $P1385, "{"
-    .return ($P1385)
+    new $P1353, "ResizablePMCArray"
+    push $P1353, "{"
+    .return ($P1353)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "metachar:sym<nqpvar>"  :subid("355_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "metachar:sym<nqpvar>"  :subid("355_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .const 'Sub' $P1393 = "357_1278500537.15927" 
-    capture_lex $P1393
-    .local string rx1388_tgt
-    .local int rx1388_pos
-    .local int rx1388_off
-    .local int rx1388_eos
-    .local int rx1388_rep
-    .local pmc rx1388_cur
-    (rx1388_cur, rx1388_pos, rx1388_tgt) = self."!cursor_start"()
-    rx1388_cur."!cursor_debug"("START ", "metachar:sym<nqpvar>")
-    .lex unicode:"$\x{a2}", rx1388_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1388_eos, rx1388_tgt
-    gt rx1388_pos, rx1388_eos, rx1388_done
-    set rx1388_off, 0
-    lt rx1388_pos, 2, rx1388_start
-    sub rx1388_off, rx1388_pos, 1
-    substr rx1388_tgt, rx1388_tgt, rx1388_off
-  rx1388_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1391_done
-    goto rxscan1391_scan
-  rxscan1391_loop:
-    ($P10) = rx1388_cur."from"()
-    inc $P10
-    set rx1388_pos, $P10
-    ge rx1388_pos, rx1388_eos, rxscan1391_done
-  rxscan1391_scan:
-    set_addr $I10, rxscan1391_loop
-    rx1388_cur."!mark_push"(0, rx1388_pos, $I10)
-  rxscan1391_done:
+    .const 'Sub' $P1361 = "357_1279529226.73787" 
+    capture_lex $P1361
+    .local string rx1356_tgt
+    .local int rx1356_pos
+    .local int rx1356_off
+    .local int rx1356_eos
+    .local int rx1356_rep
+    .local pmc rx1356_cur
+    (rx1356_cur, rx1356_pos, rx1356_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1356_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1356_eos, rx1356_tgt
+    gt rx1356_pos, rx1356_eos, rx1356_done
+    set rx1356_off, 0
+    lt rx1356_pos, 2, rx1356_start
+    sub rx1356_off, rx1356_pos, 1
+    substr rx1356_tgt, rx1356_tgt, rx1356_off
+  rx1356_start:
+    eq $I10, 1, rx1356_restart
+    rx1356_cur."!cursor_debug"("START ", "metachar:sym<nqpvar>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1359_done
+    goto rxscan1359_scan
+  rxscan1359_loop:
+    ($P10) = rx1356_cur."from"()
+    inc $P10
+    set rx1356_pos, $P10
+    ge rx1356_pos, rx1356_eos, rxscan1359_done
+  rxscan1359_scan:
+    set_addr $I10, rxscan1359_loop
+    rx1356_cur."!mark_push"(0, rx1356_pos, $I10)
+  rxscan1359_done:
 .annotate 'line', 577
   # rx enumcharlist negate=0 zerowidth
-    ge rx1388_pos, rx1388_eos, rx1388_fail
-    sub $I10, rx1388_pos, rx1388_off
-    substr $S10, rx1388_tgt, $I10, 1
+    ge rx1356_pos, rx1356_eos, rx1356_fail
+    sub $I10, rx1356_pos, rx1356_off
+    substr $S10, rx1356_tgt, $I10, 1
     index $I11, "$@", $S10
-    lt $I11, 0, rx1388_fail
+    lt $I11, 0, rx1356_fail
   # rx subrule "before" subtype=zerowidth negate=
-    rx1388_cur."!cursor_pos"(rx1388_pos)
-    .const 'Sub' $P1393 = "357_1278500537.15927" 
-    capture_lex $P1393
-    $P10 = rx1388_cur."before"($P1393)
-    unless $P10, rx1388_fail
+    rx1356_cur."!cursor_pos"(rx1356_pos)
+    .const 'Sub' $P1361 = "357_1279529226.73787" 
+    capture_lex $P1361
+    $P10 = rx1356_cur."before"($P1361)
+    unless $P10, rx1356_fail
   # rx subrule "LANG" subtype=capture negate=
-    rx1388_cur."!cursor_pos"(rx1388_pos)
-    $P10 = rx1388_cur."LANG"("MAIN", "variable")
-    unless $P10, rx1388_fail
-    rx1388_cur."!mark_push"(0, -1, 0, $P10)
+    rx1356_cur."!cursor_pos"(rx1356_pos)
+    $P10 = rx1356_cur."LANG"("MAIN", "variable")
+    unless $P10, rx1356_fail
+    rx1356_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("var")
-    rx1388_pos = $P10."pos"()
+    rx1356_pos = $P10."pos"()
 .annotate 'line', 576
   # rx pass
-    rx1388_cur."!cursor_pass"(rx1388_pos, "metachar:sym<nqpvar>")
-    rx1388_cur."!cursor_debug"("PASS  ", "metachar:sym<nqpvar>", " at pos=", rx1388_pos)
-    .return (rx1388_cur)
-  rx1388_fail:
+    rx1356_cur."!cursor_pass"(rx1356_pos, "metachar:sym<nqpvar>")
+    rx1356_cur."!cursor_debug"("PASS  ", "metachar:sym<nqpvar>", " at pos=", rx1356_pos)
+    .return (rx1356_cur)
+  rx1356_restart:
 .annotate 'line', 567
-    (rx1388_rep, rx1388_pos, $I10, $P10) = rx1388_cur."!mark_fail"(0)
-    lt rx1388_pos, -1, rx1388_done
-    eq rx1388_pos, -1, rx1388_fail
-    jump $I10
-  rx1388_done:
-    rx1388_cur."!cursor_fail"()
-    rx1388_cur."!cursor_debug"("FAIL  ", "metachar:sym<nqpvar>")
-    .return (rx1388_cur)
+    rx1356_cur."!cursor_debug"("NEXT ", "metachar:sym<nqpvar>")
+  rx1356_fail:
+    (rx1356_rep, rx1356_pos, $I10, $P10) = rx1356_cur."!mark_fail"(0)
+    lt rx1356_pos, -1, rx1356_done
+    eq rx1356_pos, -1, rx1356_fail
+    jump $I10
+  rx1356_done:
+    rx1356_cur."!cursor_fail"()
+    rx1356_cur."!cursor_debug"("FAIL  ", "metachar:sym<nqpvar>")
+    .return (rx1356_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__metachar:sym<nqpvar>"  :subid("356_1278500537.15927") :method
+.sub "!PREFIX__metachar:sym<nqpvar>"  :subid("356_1279529226.73787") :method
 .annotate 'line', 567
-    new $P1390, "ResizablePMCArray"
-    push $P1390, "$"
-    push $P1390, "@"
-    .return ($P1390)
+    new $P1358, "ResizablePMCArray"
+    push $P1358, "$"
+    push $P1358, "@"
+    .return ($P1358)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "_block1392"  :anon :subid("357_1278500537.15927") :method :outer("355_1278500537.15927")
+.sub "_block1360"  :anon :subid("357_1279529226.73787") :method :outer("355_1279529226.73787")
 .annotate 'line', 577
-    .local string rx1394_tgt
-    .local int rx1394_pos
-    .local int rx1394_off
-    .local int rx1394_eos
-    .local int rx1394_rep
-    .local pmc rx1394_cur
-    (rx1394_cur, rx1394_pos, rx1394_tgt) = self."!cursor_start"()
-    rx1394_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx1394_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1394_eos, rx1394_tgt
-    gt rx1394_pos, rx1394_eos, rx1394_done
-    set rx1394_off, 0
-    lt rx1394_pos, 2, rx1394_start
-    sub rx1394_off, rx1394_pos, 1
-    substr rx1394_tgt, rx1394_tgt, rx1394_off
-  rx1394_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1395_done
-    goto rxscan1395_scan
-  rxscan1395_loop:
-    ($P10) = rx1394_cur."from"()
-    inc $P10
-    set rx1394_pos, $P10
-    ge rx1394_pos, rx1394_eos, rxscan1395_done
-  rxscan1395_scan:
-    set_addr $I10, rxscan1395_loop
-    rx1394_cur."!mark_push"(0, rx1394_pos, $I10)
-  rxscan1395_done:
+    .local string rx1362_tgt
+    .local int rx1362_pos
+    .local int rx1362_off
+    .local int rx1362_eos
+    .local int rx1362_rep
+    .local pmc rx1362_cur
+    (rx1362_cur, rx1362_pos, rx1362_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1362_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1362_eos, rx1362_tgt
+    gt rx1362_pos, rx1362_eos, rx1362_done
+    set rx1362_off, 0
+    lt rx1362_pos, 2, rx1362_start
+    sub rx1362_off, rx1362_pos, 1
+    substr rx1362_tgt, rx1362_tgt, rx1362_off
+  rx1362_start:
+    eq $I10, 1, rx1362_restart
+    rx1362_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1363_done
+    goto rxscan1363_scan
+  rxscan1363_loop:
+    ($P10) = rx1362_cur."from"()
+    inc $P10
+    set rx1362_pos, $P10
+    ge rx1362_pos, rx1362_eos, rxscan1363_done
+  rxscan1363_scan:
+    set_addr $I10, rxscan1363_loop
+    rx1362_cur."!mark_push"(0, rx1362_pos, $I10)
+  rxscan1363_done:
   # rx charclass .
-    ge rx1394_pos, rx1394_eos, rx1394_fail
-    inc rx1394_pos
+    ge rx1362_pos, rx1362_eos, rx1362_fail
+    inc rx1362_pos
   # rx charclass w
-    ge rx1394_pos, rx1394_eos, rx1394_fail
-    sub $I10, rx1394_pos, rx1394_off
-    is_cclass $I11, 8192, rx1394_tgt, $I10
-    unless $I11, rx1394_fail
-    inc rx1394_pos
-  # rx pass
-    rx1394_cur."!cursor_pass"(rx1394_pos, "")
-    rx1394_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1394_pos)
-    .return (rx1394_cur)
-  rx1394_fail:
-    (rx1394_rep, rx1394_pos, $I10, $P10) = rx1394_cur."!mark_fail"(0)
-    lt rx1394_pos, -1, rx1394_done
-    eq rx1394_pos, -1, rx1394_fail
-    jump $I10
-  rx1394_done:
-    rx1394_cur."!cursor_fail"()
-    rx1394_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx1394_cur)
+    ge rx1362_pos, rx1362_eos, rx1362_fail
+    sub $I10, rx1362_pos, rx1362_off
+    is_cclass $I11, 8192, rx1362_tgt, $I10
+    unless $I11, rx1362_fail
+    inc rx1362_pos
+  # rx pass
+    rx1362_cur."!cursor_pass"(rx1362_pos, "")
+    rx1362_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1362_pos)
+    .return (rx1362_cur)
+  rx1362_restart:
+    rx1362_cur."!cursor_debug"("NEXT ", "")
+  rx1362_fail:
+    (rx1362_rep, rx1362_pos, $I10, $P10) = rx1362_cur."!mark_fail"(0)
+    lt rx1362_pos, -1, rx1362_done
+    eq rx1362_pos, -1, rx1362_fail
+    jump $I10
+  rx1362_done:
+    rx1362_cur."!cursor_fail"()
+    rx1362_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx1362_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "assertion:sym<{ }>"  :subid("358_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "assertion:sym<{ }>"  :subid("358_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .local string rx1397_tgt
-    .local int rx1397_pos
-    .local int rx1397_off
-    .local int rx1397_eos
-    .local int rx1397_rep
-    .local pmc rx1397_cur
-    (rx1397_cur, rx1397_pos, rx1397_tgt) = self."!cursor_start"()
-    rx1397_cur."!cursor_debug"("START ", "assertion:sym<{ }>")
-    .lex unicode:"$\x{a2}", rx1397_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1397_eos, rx1397_tgt
-    gt rx1397_pos, rx1397_eos, rx1397_done
-    set rx1397_off, 0
-    lt rx1397_pos, 2, rx1397_start
-    sub rx1397_off, rx1397_pos, 1
-    substr rx1397_tgt, rx1397_tgt, rx1397_off
-  rx1397_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1400_done
-    goto rxscan1400_scan
-  rxscan1400_loop:
-    ($P10) = rx1397_cur."from"()
-    inc $P10
-    set rx1397_pos, $P10
-    ge rx1397_pos, rx1397_eos, rxscan1400_done
-  rxscan1400_scan:
-    set_addr $I10, rxscan1400_loop
-    rx1397_cur."!mark_push"(0, rx1397_pos, $I10)
-  rxscan1400_done:
+    .local string rx1365_tgt
+    .local int rx1365_pos
+    .local int rx1365_off
+    .local int rx1365_eos
+    .local int rx1365_rep
+    .local pmc rx1365_cur
+    (rx1365_cur, rx1365_pos, rx1365_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1365_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1365_eos, rx1365_tgt
+    gt rx1365_pos, rx1365_eos, rx1365_done
+    set rx1365_off, 0
+    lt rx1365_pos, 2, rx1365_start
+    sub rx1365_off, rx1365_pos, 1
+    substr rx1365_tgt, rx1365_tgt, rx1365_off
+  rx1365_start:
+    eq $I10, 1, rx1365_restart
+    rx1365_cur."!cursor_debug"("START ", "assertion:sym<{ }>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1368_done
+    goto rxscan1368_scan
+  rxscan1368_loop:
+    ($P10) = rx1365_cur."from"()
+    inc $P10
+    set rx1365_pos, $P10
+    ge rx1365_pos, rx1365_eos, rxscan1368_done
+  rxscan1368_scan:
+    set_addr $I10, rxscan1368_loop
+    rx1365_cur."!mark_push"(0, rx1365_pos, $I10)
+  rxscan1368_done:
 .annotate 'line', 581
   # rx enumcharlist negate=0 zerowidth
-    ge rx1397_pos, rx1397_eos, rx1397_fail
-    sub $I10, rx1397_pos, rx1397_off
-    substr $S10, rx1397_tgt, $I10, 1
+    ge rx1365_pos, rx1365_eos, rx1365_fail
+    sub $I10, rx1365_pos, rx1365_off
+    substr $S10, rx1365_tgt, $I10, 1
     index $I11, "{", $S10
-    lt $I11, 0, rx1397_fail
+    lt $I11, 0, rx1365_fail
   # rx subrule "codeblock" subtype=capture negate=
-    rx1397_cur."!cursor_pos"(rx1397_pos)
-    $P10 = rx1397_cur."codeblock"()
-    unless $P10, rx1397_fail
-    rx1397_cur."!mark_push"(0, -1, 0, $P10)
+    rx1365_cur."!cursor_pos"(rx1365_pos)
+    $P10 = rx1365_cur."codeblock"()
+    unless $P10, rx1365_fail
+    rx1365_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("codeblock")
-    rx1397_pos = $P10."pos"()
+    rx1365_pos = $P10."pos"()
 .annotate 'line', 580
   # rx pass
-    rx1397_cur."!cursor_pass"(rx1397_pos, "assertion:sym<{ }>")
-    rx1397_cur."!cursor_debug"("PASS  ", "assertion:sym<{ }>", " at pos=", rx1397_pos)
-    .return (rx1397_cur)
-  rx1397_fail:
+    rx1365_cur."!cursor_pass"(rx1365_pos, "assertion:sym<{ }>")
+    rx1365_cur."!cursor_debug"("PASS  ", "assertion:sym<{ }>", " at pos=", rx1365_pos)
+    .return (rx1365_cur)
+  rx1365_restart:
 .annotate 'line', 567
-    (rx1397_rep, rx1397_pos, $I10, $P10) = rx1397_cur."!mark_fail"(0)
-    lt rx1397_pos, -1, rx1397_done
-    eq rx1397_pos, -1, rx1397_fail
-    jump $I10
-  rx1397_done:
-    rx1397_cur."!cursor_fail"()
-    rx1397_cur."!cursor_debug"("FAIL  ", "assertion:sym<{ }>")
-    .return (rx1397_cur)
+    rx1365_cur."!cursor_debug"("NEXT ", "assertion:sym<{ }>")
+  rx1365_fail:
+    (rx1365_rep, rx1365_pos, $I10, $P10) = rx1365_cur."!mark_fail"(0)
+    lt rx1365_pos, -1, rx1365_done
+    eq rx1365_pos, -1, rx1365_fail
+    jump $I10
+  rx1365_done:
+    rx1365_cur."!cursor_fail"()
+    rx1365_cur."!cursor_debug"("FAIL  ", "assertion:sym<{ }>")
+    .return (rx1365_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__assertion:sym<{ }>"  :subid("359_1278500537.15927") :method
+.sub "!PREFIX__assertion:sym<{ }>"  :subid("359_1279529226.73787") :method
 .annotate 'line', 567
-    new $P1399, "ResizablePMCArray"
-    push $P1399, "{"
-    .return ($P1399)
+    new $P1367, "ResizablePMCArray"
+    push $P1367, "{"
+    .return ($P1367)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "assertion:sym<?{ }>"  :subid("360_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "assertion:sym<?{ }>"  :subid("360_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .const 'Sub' $P1407 = "362_1278500537.15927" 
-    capture_lex $P1407
-    .local string rx1402_tgt
-    .local int rx1402_pos
-    .local int rx1402_off
-    .local int rx1402_eos
-    .local int rx1402_rep
-    .local pmc rx1402_cur
-    (rx1402_cur, rx1402_pos, rx1402_tgt) = self."!cursor_start"()
-    rx1402_cur."!cursor_debug"("START ", "assertion:sym<?{ }>")
-    .lex unicode:"$\x{a2}", rx1402_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1402_eos, rx1402_tgt
-    gt rx1402_pos, rx1402_eos, rx1402_done
-    set rx1402_off, 0
-    lt rx1402_pos, 2, rx1402_start
-    sub rx1402_off, rx1402_pos, 1
-    substr rx1402_tgt, rx1402_tgt, rx1402_off
-  rx1402_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1405_done
-    goto rxscan1405_scan
-  rxscan1405_loop:
-    ($P10) = rx1402_cur."from"()
-    inc $P10
-    set rx1402_pos, $P10
-    ge rx1402_pos, rx1402_eos, rxscan1405_done
-  rxscan1405_scan:
-    set_addr $I10, rxscan1405_loop
-    rx1402_cur."!mark_push"(0, rx1402_pos, $I10)
-  rxscan1405_done:
+    .const 'Sub' $P1375 = "362_1279529226.73787" 
+    capture_lex $P1375
+    .local string rx1370_tgt
+    .local int rx1370_pos
+    .local int rx1370_off
+    .local int rx1370_eos
+    .local int rx1370_rep
+    .local pmc rx1370_cur
+    (rx1370_cur, rx1370_pos, rx1370_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1370_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1370_eos, rx1370_tgt
+    gt rx1370_pos, rx1370_eos, rx1370_done
+    set rx1370_off, 0
+    lt rx1370_pos, 2, rx1370_start
+    sub rx1370_off, rx1370_pos, 1
+    substr rx1370_tgt, rx1370_tgt, rx1370_off
+  rx1370_start:
+    eq $I10, 1, rx1370_restart
+    rx1370_cur."!cursor_debug"("START ", "assertion:sym<?{ }>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1373_done
+    goto rxscan1373_scan
+  rxscan1373_loop:
+    ($P10) = rx1370_cur."from"()
+    inc $P10
+    set rx1370_pos, $P10
+    ge rx1370_pos, rx1370_eos, rxscan1373_done
+  rxscan1373_scan:
+    set_addr $I10, rxscan1373_loop
+    rx1370_cur."!mark_push"(0, rx1370_pos, $I10)
+  rxscan1373_done:
 .annotate 'line', 585
   # rx subcapture "zw"
-    set_addr $I10, rxcap_1410_fail
-    rx1402_cur."!mark_push"(0, rx1402_pos, $I10)
+    set_addr $I10, rxcap_1378_fail
+    rx1370_cur."!mark_push"(0, rx1370_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx1402_pos, rx1402_eos, rx1402_fail
-    sub $I10, rx1402_pos, rx1402_off
-    substr $S10, rx1402_tgt, $I10, 1
+    ge rx1370_pos, rx1370_eos, rx1370_fail
+    sub $I10, rx1370_pos, rx1370_off
+    substr $S10, rx1370_tgt, $I10, 1
     index $I11, "?!", $S10
-    lt $I11, 0, rx1402_fail
-    inc rx1402_pos
+    lt $I11, 0, rx1370_fail
+    inc rx1370_pos
   # rx subrule "before" subtype=zerowidth negate=
-    rx1402_cur."!cursor_pos"(rx1402_pos)
-    .const 'Sub' $P1407 = "362_1278500537.15927" 
-    capture_lex $P1407
-    $P10 = rx1402_cur."before"($P1407)
-    unless $P10, rx1402_fail
-    set_addr $I10, rxcap_1410_fail
-    ($I12, $I11) = rx1402_cur."!mark_peek"($I10)
-    rx1402_cur."!cursor_pos"($I11)
-    ($P10) = rx1402_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx1402_pos, "")
-    rx1402_cur."!mark_push"(0, -1, 0, $P10)
+    rx1370_cur."!cursor_pos"(rx1370_pos)
+    .const 'Sub' $P1375 = "362_1279529226.73787" 
+    capture_lex $P1375
+    $P10 = rx1370_cur."before"($P1375)
+    unless $P10, rx1370_fail
+    set_addr $I10, rxcap_1378_fail
+    ($I12, $I11) = rx1370_cur."!mark_peek"($I10)
+    rx1370_cur."!cursor_pos"($I11)
+    ($P10) = rx1370_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx1370_pos, "")
+    rx1370_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("zw")
-    goto rxcap_1410_done
-  rxcap_1410_fail:
-    goto rx1402_fail
-  rxcap_1410_done:
+    goto rxcap_1378_done
+  rxcap_1378_fail:
+    goto rx1370_fail
+  rxcap_1378_done:
   # rx subrule "codeblock" subtype=capture negate=
-    rx1402_cur."!cursor_pos"(rx1402_pos)
-    $P10 = rx1402_cur."codeblock"()
-    unless $P10, rx1402_fail
-    rx1402_cur."!mark_push"(0, -1, 0, $P10)
+    rx1370_cur."!cursor_pos"(rx1370_pos)
+    $P10 = rx1370_cur."codeblock"()
+    unless $P10, rx1370_fail
+    rx1370_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("codeblock")
-    rx1402_pos = $P10."pos"()
+    rx1370_pos = $P10."pos"()
 .annotate 'line', 584
   # rx pass
-    rx1402_cur."!cursor_pass"(rx1402_pos, "assertion:sym<?{ }>")
-    rx1402_cur."!cursor_debug"("PASS  ", "assertion:sym<?{ }>", " at pos=", rx1402_pos)
-    .return (rx1402_cur)
-  rx1402_fail:
+    rx1370_cur."!cursor_pass"(rx1370_pos, "assertion:sym<?{ }>")
+    rx1370_cur."!cursor_debug"("PASS  ", "assertion:sym<?{ }>", " at pos=", rx1370_pos)
+    .return (rx1370_cur)
+  rx1370_restart:
 .annotate 'line', 567
-    (rx1402_rep, rx1402_pos, $I10, $P10) = rx1402_cur."!mark_fail"(0)
-    lt rx1402_pos, -1, rx1402_done
-    eq rx1402_pos, -1, rx1402_fail
-    jump $I10
-  rx1402_done:
-    rx1402_cur."!cursor_fail"()
-    rx1402_cur."!cursor_debug"("FAIL  ", "assertion:sym<?{ }>")
-    .return (rx1402_cur)
+    rx1370_cur."!cursor_debug"("NEXT ", "assertion:sym<?{ }>")
+  rx1370_fail:
+    (rx1370_rep, rx1370_pos, $I10, $P10) = rx1370_cur."!mark_fail"(0)
+    lt rx1370_pos, -1, rx1370_done
+    eq rx1370_pos, -1, rx1370_fail
+    jump $I10
+  rx1370_done:
+    rx1370_cur."!cursor_fail"()
+    rx1370_cur."!cursor_debug"("FAIL  ", "assertion:sym<?{ }>")
+    .return (rx1370_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__assertion:sym<?{ }>"  :subid("361_1278500537.15927") :method
+.sub "!PREFIX__assertion:sym<?{ }>"  :subid("361_1279529226.73787") :method
 .annotate 'line', 567
-    new $P1404, "ResizablePMCArray"
-    push $P1404, "!"
-    push $P1404, "?"
-    .return ($P1404)
+    new $P1372, "ResizablePMCArray"
+    push $P1372, "!"
+    push $P1372, "?"
+    .return ($P1372)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "_block1406"  :anon :subid("362_1278500537.15927") :method :outer("360_1278500537.15927")
+.sub "_block1374"  :anon :subid("362_1279529226.73787") :method :outer("360_1279529226.73787")
 .annotate 'line', 585
-    .local string rx1408_tgt
-    .local int rx1408_pos
-    .local int rx1408_off
-    .local int rx1408_eos
-    .local int rx1408_rep
-    .local pmc rx1408_cur
-    (rx1408_cur, rx1408_pos, rx1408_tgt) = self."!cursor_start"()
-    rx1408_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx1408_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1408_eos, rx1408_tgt
-    gt rx1408_pos, rx1408_eos, rx1408_done
-    set rx1408_off, 0
-    lt rx1408_pos, 2, rx1408_start
-    sub rx1408_off, rx1408_pos, 1
-    substr rx1408_tgt, rx1408_tgt, rx1408_off
-  rx1408_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1409_done
-    goto rxscan1409_scan
-  rxscan1409_loop:
-    ($P10) = rx1408_cur."from"()
-    inc $P10
-    set rx1408_pos, $P10
-    ge rx1408_pos, rx1408_eos, rxscan1409_done
-  rxscan1409_scan:
-    set_addr $I10, rxscan1409_loop
-    rx1408_cur."!mark_push"(0, rx1408_pos, $I10)
-  rxscan1409_done:
+    .local string rx1376_tgt
+    .local int rx1376_pos
+    .local int rx1376_off
+    .local int rx1376_eos
+    .local int rx1376_rep
+    .local pmc rx1376_cur
+    (rx1376_cur, rx1376_pos, rx1376_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1376_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1376_eos, rx1376_tgt
+    gt rx1376_pos, rx1376_eos, rx1376_done
+    set rx1376_off, 0
+    lt rx1376_pos, 2, rx1376_start
+    sub rx1376_off, rx1376_pos, 1
+    substr rx1376_tgt, rx1376_tgt, rx1376_off
+  rx1376_start:
+    eq $I10, 1, rx1376_restart
+    rx1376_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1377_done
+    goto rxscan1377_scan
+  rxscan1377_loop:
+    ($P10) = rx1376_cur."from"()
+    inc $P10
+    set rx1376_pos, $P10
+    ge rx1376_pos, rx1376_eos, rxscan1377_done
+  rxscan1377_scan:
+    set_addr $I10, rxscan1377_loop
+    rx1376_cur."!mark_push"(0, rx1376_pos, $I10)
+  rxscan1377_done:
   # rx literal  "{"
-    add $I11, rx1408_pos, 1
-    gt $I11, rx1408_eos, rx1408_fail
-    sub $I11, rx1408_pos, rx1408_off
-    substr $S10, rx1408_tgt, $I11, 1
-    ne $S10, "{", rx1408_fail
-    add rx1408_pos, 1
-  # rx pass
-    rx1408_cur."!cursor_pass"(rx1408_pos, "")
-    rx1408_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1408_pos)
-    .return (rx1408_cur)
-  rx1408_fail:
-    (rx1408_rep, rx1408_pos, $I10, $P10) = rx1408_cur."!mark_fail"(0)
-    lt rx1408_pos, -1, rx1408_done
-    eq rx1408_pos, -1, rx1408_fail
-    jump $I10
-  rx1408_done:
-    rx1408_cur."!cursor_fail"()
-    rx1408_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx1408_cur)
+    add $I11, rx1376_pos, 1
+    gt $I11, rx1376_eos, rx1376_fail
+    sub $I11, rx1376_pos, rx1376_off
+    substr $S10, rx1376_tgt, $I11, 1
+    ne $S10, "{", rx1376_fail
+    add rx1376_pos, 1
+  # rx pass
+    rx1376_cur."!cursor_pass"(rx1376_pos, "")
+    rx1376_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1376_pos)
+    .return (rx1376_cur)
+  rx1376_restart:
+    rx1376_cur."!cursor_debug"("NEXT ", "")
+  rx1376_fail:
+    (rx1376_rep, rx1376_pos, $I10, $P10) = rx1376_cur."!mark_fail"(0)
+    lt rx1376_pos, -1, rx1376_done
+    eq rx1376_pos, -1, rx1376_fail
+    jump $I10
+  rx1376_done:
+    rx1376_cur."!cursor_fail"()
+    rx1376_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx1376_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "assertion:sym<name>"  :subid("363_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "assertion:sym<name>"  :subid("363_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .const 'Sub' $P1420 = "365_1278500537.15927" 
-    capture_lex $P1420
-    .local string rx1412_tgt
-    .local int rx1412_pos
-    .local int rx1412_off
-    .local int rx1412_eos
-    .local int rx1412_rep
-    .local pmc rx1412_cur
-    (rx1412_cur, rx1412_pos, rx1412_tgt) = self."!cursor_start"()
-    rx1412_cur."!cursor_debug"("START ", "assertion:sym<name>")
-    rx1412_cur."!cursor_caparray"("nibbler", "arglist", "assertion")
-    .lex unicode:"$\x{a2}", rx1412_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1412_eos, rx1412_tgt
-    gt rx1412_pos, rx1412_eos, rx1412_done
-    set rx1412_off, 0
-    lt rx1412_pos, 2, rx1412_start
-    sub rx1412_off, rx1412_pos, 1
-    substr rx1412_tgt, rx1412_tgt, rx1412_off
-  rx1412_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1416_done
-    goto rxscan1416_scan
-  rxscan1416_loop:
-    ($P10) = rx1412_cur."from"()
-    inc $P10
-    set rx1412_pos, $P10
-    ge rx1412_pos, rx1412_eos, rxscan1416_done
-  rxscan1416_scan:
-    set_addr $I10, rxscan1416_loop
-    rx1412_cur."!mark_push"(0, rx1412_pos, $I10)
-  rxscan1416_done:
+    .const 'Sub' $P1388 = "365_1279529226.73787" 
+    capture_lex $P1388
+    .local string rx1380_tgt
+    .local int rx1380_pos
+    .local int rx1380_off
+    .local int rx1380_eos
+    .local int rx1380_rep
+    .local pmc rx1380_cur
+    (rx1380_cur, rx1380_pos, rx1380_tgt, $I10) = self."!cursor_start"()
+    rx1380_cur."!cursor_caparray"("arglist", "nibbler", "assertion")
+    .lex unicode:"$\x{a2}", rx1380_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1380_eos, rx1380_tgt
+    gt rx1380_pos, rx1380_eos, rx1380_done
+    set rx1380_off, 0
+    lt rx1380_pos, 2, rx1380_start
+    sub rx1380_off, rx1380_pos, 1
+    substr rx1380_tgt, rx1380_tgt, rx1380_off
+  rx1380_start:
+    eq $I10, 1, rx1380_restart
+    rx1380_cur."!cursor_debug"("START ", "assertion:sym<name>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1384_done
+    goto rxscan1384_scan
+  rxscan1384_loop:
+    ($P10) = rx1380_cur."from"()
+    inc $P10
+    set rx1380_pos, $P10
+    ge rx1380_pos, rx1380_eos, rxscan1384_done
+  rxscan1384_scan:
+    set_addr $I10, rxscan1384_loop
+    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
+  rxscan1384_done:
 .annotate 'line', 589
   # rx subrule "identifier" subtype=capture negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    $P10 = rx1412_cur."identifier"()
-    unless $P10, rx1412_fail
-    rx1412_cur."!mark_push"(0, -1, 0, $P10)
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    $P10 = rx1380_cur."identifier"()
+    unless $P10, rx1380_fail
+    rx1380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("longname")
-    rx1412_pos = $P10."pos"()
+    rx1380_pos = $P10."pos"()
 .annotate 'line', 596
-  # rx rxquantr1417 ** 0..1
-    set_addr $I1423, rxquantr1417_done
-    rx1412_cur."!mark_push"(0, rx1412_pos, $I1423)
-  rxquantr1417_loop:
-  alt1418_0:
+  # rx rxquantr1385 ** 0..1
+    set_addr $I10, rxquantr1385_done
+    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
+  rxquantr1385_loop:
+  alt1386_0:
 .annotate 'line', 590
-    set_addr $I10, alt1418_1
-    rx1412_cur."!mark_push"(0, rx1412_pos, $I10)
+    set_addr $I10, alt1386_1
+    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
 .annotate 'line', 591
   # rx subrule "before" subtype=zerowidth negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    .const 'Sub' $P1420 = "365_1278500537.15927" 
-    capture_lex $P1420
-    $P10 = rx1412_cur."before"($P1420)
-    unless $P10, rx1412_fail
-    goto alt1418_end
-  alt1418_1:
-    set_addr $I10, alt1418_2
-    rx1412_cur."!mark_push"(0, rx1412_pos, $I10)
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    .const 'Sub' $P1388 = "365_1279529226.73787" 
+    capture_lex $P1388
+    $P10 = rx1380_cur."before"($P1388)
+    unless $P10, rx1380_fail
+    goto alt1386_end
+  alt1386_1:
+    set_addr $I10, alt1386_2
+    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
 .annotate 'line', 592
   # rx literal  "="
-    add $I11, rx1412_pos, 1
-    gt $I11, rx1412_eos, rx1412_fail
-    sub $I11, rx1412_pos, rx1412_off
-    substr $S10, rx1412_tgt, $I11, 1
-    ne $S10, "=", rx1412_fail
-    add rx1412_pos, 1
+    add $I11, rx1380_pos, 1
+    gt $I11, rx1380_eos, rx1380_fail
+    sub $I11, rx1380_pos, rx1380_off
+    substr $S10, rx1380_tgt, $I11, 1
+    ne $S10, "=", rx1380_fail
+    add rx1380_pos, 1
   # rx subrule "assertion" subtype=capture negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    $P10 = rx1412_cur."assertion"()
-    unless $P10, rx1412_fail
-    rx1412_cur."!mark_push"(0, -1, 0, $P10)
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    $P10 = rx1380_cur."assertion"()
+    unless $P10, rx1380_fail
+    rx1380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("assertion")
-    rx1412_pos = $P10."pos"()
-    goto alt1418_end
-  alt1418_2:
-    set_addr $I10, alt1418_3
-    rx1412_cur."!mark_push"(0, rx1412_pos, $I10)
+    rx1380_pos = $P10."pos"()
+    goto alt1386_end
+  alt1386_2:
+    set_addr $I10, alt1386_3
+    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
 .annotate 'line', 593
   # rx literal  ":"
-    add $I11, rx1412_pos, 1
-    gt $I11, rx1412_eos, rx1412_fail
-    sub $I11, rx1412_pos, rx1412_off
-    substr $S10, rx1412_tgt, $I11, 1
-    ne $S10, ":", rx1412_fail
-    add rx1412_pos, 1
+    add $I11, rx1380_pos, 1
+    gt $I11, rx1380_eos, rx1380_fail
+    sub $I11, rx1380_pos, rx1380_off
+    substr $S10, rx1380_tgt, $I11, 1
+    ne $S10, ":", rx1380_fail
+    add rx1380_pos, 1
   # rx subrule "arglist" subtype=capture negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    $P10 = rx1412_cur."arglist"()
-    unless $P10, rx1412_fail
-    rx1412_cur."!mark_push"(0, -1, 0, $P10)
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    $P10 = rx1380_cur."arglist"()
+    unless $P10, rx1380_fail
+    rx1380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("arglist")
-    rx1412_pos = $P10."pos"()
-    goto alt1418_end
-  alt1418_3:
-    set_addr $I10, alt1418_4
-    rx1412_cur."!mark_push"(0, rx1412_pos, $I10)
+    rx1380_pos = $P10."pos"()
+    goto alt1386_end
+  alt1386_3:
+    set_addr $I10, alt1386_4
+    rx1380_cur."!mark_push"(0, rx1380_pos, $I10)
 .annotate 'line', 594
   # rx literal  "("
-    add $I11, rx1412_pos, 1
-    gt $I11, rx1412_eos, rx1412_fail
-    sub $I11, rx1412_pos, rx1412_off
-    substr $S10, rx1412_tgt, $I11, 1
-    ne $S10, "(", rx1412_fail
-    add rx1412_pos, 1
+    add $I11, rx1380_pos, 1
+    gt $I11, rx1380_eos, rx1380_fail
+    sub $I11, rx1380_pos, rx1380_off
+    substr $S10, rx1380_tgt, $I11, 1
+    ne $S10, "(", rx1380_fail
+    add rx1380_pos, 1
   # rx subrule "LANG" subtype=capture negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    $P10 = rx1412_cur."LANG"("MAIN", "arglist")
-    unless $P10, rx1412_fail
-    rx1412_cur."!mark_push"(0, -1, 0, $P10)
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    $P10 = rx1380_cur."LANG"("MAIN", "arglist")
+    unless $P10, rx1380_fail
+    rx1380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("arglist")
-    rx1412_pos = $P10."pos"()
+    rx1380_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx1412_pos, 1
-    gt $I11, rx1412_eos, rx1412_fail
-    sub $I11, rx1412_pos, rx1412_off
-    substr $S10, rx1412_tgt, $I11, 1
-    ne $S10, ")", rx1412_fail
-    add rx1412_pos, 1
-    goto alt1418_end
-  alt1418_4:
+    add $I11, rx1380_pos, 1
+    gt $I11, rx1380_eos, rx1380_fail
+    sub $I11, rx1380_pos, rx1380_off
+    substr $S10, rx1380_tgt, $I11, 1
+    ne $S10, ")", rx1380_fail
+    add rx1380_pos, 1
+    goto alt1386_end
+  alt1386_4:
 .annotate 'line', 595
   # rx subrule "normspace" subtype=method negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    $P10 = rx1412_cur."normspace"()
-    unless $P10, rx1412_fail
-    rx1412_pos = $P10."pos"()
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    $P10 = rx1380_cur."normspace"()
+    unless $P10, rx1380_fail
+    rx1380_pos = $P10."pos"()
   # rx subrule "nibbler" subtype=capture negate=
-    rx1412_cur."!cursor_pos"(rx1412_pos)
-    $P10 = rx1412_cur."nibbler"()
-    unless $P10, rx1412_fail
-    rx1412_cur."!mark_push"(0, -1, 0, $P10)
+    rx1380_cur."!cursor_pos"(rx1380_pos)
+    $P10 = rx1380_cur."nibbler"()
+    unless $P10, rx1380_fail
+    rx1380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("nibbler")
-    rx1412_pos = $P10."pos"()
-  alt1418_end:
+    rx1380_pos = $P10."pos"()
+  alt1386_end:
 .annotate 'line', 596
-    (rx1412_rep) = rx1412_cur."!mark_commit"($I1423)
-  rxquantr1417_done:
+    set_addr $I10, rxquantr1385_done
+    (rx1380_rep) = rx1380_cur."!mark_commit"($I10)
+  rxquantr1385_done:
 .annotate 'line', 588
   # rx pass
-    rx1412_cur."!cursor_pass"(rx1412_pos, "assertion:sym<name>")
-    rx1412_cur."!cursor_debug"("PASS  ", "assertion:sym<name>", " at pos=", rx1412_pos)
-    .return (rx1412_cur)
-  rx1412_fail:
+    rx1380_cur."!cursor_pass"(rx1380_pos, "assertion:sym<name>")
+    rx1380_cur."!cursor_debug"("PASS  ", "assertion:sym<name>", " at pos=", rx1380_pos)
+    .return (rx1380_cur)
+  rx1380_restart:
 .annotate 'line', 567
-    (rx1412_rep, rx1412_pos, $I10, $P10) = rx1412_cur."!mark_fail"(0)
-    lt rx1412_pos, -1, rx1412_done
-    eq rx1412_pos, -1, rx1412_fail
-    jump $I10
-  rx1412_done:
-    rx1412_cur."!cursor_fail"()
-    rx1412_cur."!cursor_debug"("FAIL  ", "assertion:sym<name>")
-    .return (rx1412_cur)
+    rx1380_cur."!cursor_debug"("NEXT ", "assertion:sym<name>")
+  rx1380_fail:
+    (rx1380_rep, rx1380_pos, $I10, $P10) = rx1380_cur."!mark_fail"(0)
+    lt rx1380_pos, -1, rx1380_done
+    eq rx1380_pos, -1, rx1380_fail
+    jump $I10
+  rx1380_done:
+    rx1380_cur."!cursor_fail"()
+    rx1380_cur."!cursor_debug"("FAIL  ", "assertion:sym<name>")
+    .return (rx1380_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__assertion:sym<name>"  :subid("364_1278500537.15927") :method
+.sub "!PREFIX__assertion:sym<name>"  :subid("364_1279529226.73787") :method
 .annotate 'line', 567
-    $P1414 = self."!PREFIX__!subrule"("identifier", "")
-    new $P1415, "ResizablePMCArray"
-    push $P1415, $P1414
-    .return ($P1415)
+    $P1382 = self."!PREFIX__!subrule"("identifier", "")
+    new $P1383, "ResizablePMCArray"
+    push $P1383, $P1382
+    .return ($P1383)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "_block1419"  :anon :subid("365_1278500537.15927") :method :outer("363_1278500537.15927")
+.sub "_block1387"  :anon :subid("365_1279529226.73787") :method :outer("363_1279529226.73787")
 .annotate 'line', 591
-    .local string rx1421_tgt
-    .local int rx1421_pos
-    .local int rx1421_off
-    .local int rx1421_eos
-    .local int rx1421_rep
-    .local pmc rx1421_cur
-    (rx1421_cur, rx1421_pos, rx1421_tgt) = self."!cursor_start"()
-    rx1421_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx1421_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1421_eos, rx1421_tgt
-    gt rx1421_pos, rx1421_eos, rx1421_done
-    set rx1421_off, 0
-    lt rx1421_pos, 2, rx1421_start
-    sub rx1421_off, rx1421_pos, 1
-    substr rx1421_tgt, rx1421_tgt, rx1421_off
-  rx1421_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1422_done
-    goto rxscan1422_scan
-  rxscan1422_loop:
-    ($P10) = rx1421_cur."from"()
-    inc $P10
-    set rx1421_pos, $P10
-    ge rx1421_pos, rx1421_eos, rxscan1422_done
-  rxscan1422_scan:
-    set_addr $I10, rxscan1422_loop
-    rx1421_cur."!mark_push"(0, rx1421_pos, $I10)
-  rxscan1422_done:
+    .local string rx1389_tgt
+    .local int rx1389_pos
+    .local int rx1389_off
+    .local int rx1389_eos
+    .local int rx1389_rep
+    .local pmc rx1389_cur
+    (rx1389_cur, rx1389_pos, rx1389_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1389_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1389_eos, rx1389_tgt
+    gt rx1389_pos, rx1389_eos, rx1389_done
+    set rx1389_off, 0
+    lt rx1389_pos, 2, rx1389_start
+    sub rx1389_off, rx1389_pos, 1
+    substr rx1389_tgt, rx1389_tgt, rx1389_off
+  rx1389_start:
+    eq $I10, 1, rx1389_restart
+    rx1389_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1390_done
+    goto rxscan1390_scan
+  rxscan1390_loop:
+    ($P10) = rx1389_cur."from"()
+    inc $P10
+    set rx1389_pos, $P10
+    ge rx1389_pos, rx1389_eos, rxscan1390_done
+  rxscan1390_scan:
+    set_addr $I10, rxscan1390_loop
+    rx1389_cur."!mark_push"(0, rx1389_pos, $I10)
+  rxscan1390_done:
   # rx literal  ">"
-    add $I11, rx1421_pos, 1
-    gt $I11, rx1421_eos, rx1421_fail
-    sub $I11, rx1421_pos, rx1421_off
-    substr $S10, rx1421_tgt, $I11, 1
-    ne $S10, ">", rx1421_fail
-    add rx1421_pos, 1
-  # rx pass
-    rx1421_cur."!cursor_pass"(rx1421_pos, "")
-    rx1421_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1421_pos)
-    .return (rx1421_cur)
-  rx1421_fail:
-    (rx1421_rep, rx1421_pos, $I10, $P10) = rx1421_cur."!mark_fail"(0)
-    lt rx1421_pos, -1, rx1421_done
-    eq rx1421_pos, -1, rx1421_fail
-    jump $I10
-  rx1421_done:
-    rx1421_cur."!cursor_fail"()
-    rx1421_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx1421_cur)
+    add $I11, rx1389_pos, 1
+    gt $I11, rx1389_eos, rx1389_fail
+    sub $I11, rx1389_pos, rx1389_off
+    substr $S10, rx1389_tgt, $I11, 1
+    ne $S10, ">", rx1389_fail
+    add rx1389_pos, 1
+  # rx pass
+    rx1389_cur."!cursor_pass"(rx1389_pos, "")
+    rx1389_cur."!cursor_debug"("PASS  ", "", " at pos=", rx1389_pos)
+    .return (rx1389_cur)
+  rx1389_restart:
+    rx1389_cur."!cursor_debug"("NEXT ", "")
+  rx1389_fail:
+    (rx1389_rep, rx1389_pos, $I10, $P10) = rx1389_cur."!mark_fail"(0)
+    lt rx1389_pos, -1, rx1389_done
+    eq rx1389_pos, -1, rx1389_fail
+    jump $I10
+  rx1389_done:
+    rx1389_cur."!cursor_fail"()
+    rx1389_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx1389_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "assertion:sym<var>"  :subid("366_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "assertion:sym<var>"  :subid("366_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .local string rx1425_tgt
-    .local int rx1425_pos
-    .local int rx1425_off
-    .local int rx1425_eos
-    .local int rx1425_rep
-    .local pmc rx1425_cur
-    (rx1425_cur, rx1425_pos, rx1425_tgt) = self."!cursor_start"()
-    rx1425_cur."!cursor_debug"("START ", "assertion:sym<var>")
-    .lex unicode:"$\x{a2}", rx1425_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1425_eos, rx1425_tgt
-    gt rx1425_pos, rx1425_eos, rx1425_done
-    set rx1425_off, 0
-    lt rx1425_pos, 2, rx1425_start
-    sub rx1425_off, rx1425_pos, 1
-    substr rx1425_tgt, rx1425_tgt, rx1425_off
-  rx1425_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1428_done
-    goto rxscan1428_scan
-  rxscan1428_loop:
-    ($P10) = rx1425_cur."from"()
-    inc $P10
-    set rx1425_pos, $P10
-    ge rx1425_pos, rx1425_eos, rxscan1428_done
-  rxscan1428_scan:
-    set_addr $I10, rxscan1428_loop
-    rx1425_cur."!mark_push"(0, rx1425_pos, $I10)
-  rxscan1428_done:
+    .local string rx1392_tgt
+    .local int rx1392_pos
+    .local int rx1392_off
+    .local int rx1392_eos
+    .local int rx1392_rep
+    .local pmc rx1392_cur
+    (rx1392_cur, rx1392_pos, rx1392_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1392_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1392_eos, rx1392_tgt
+    gt rx1392_pos, rx1392_eos, rx1392_done
+    set rx1392_off, 0
+    lt rx1392_pos, 2, rx1392_start
+    sub rx1392_off, rx1392_pos, 1
+    substr rx1392_tgt, rx1392_tgt, rx1392_off
+  rx1392_start:
+    eq $I10, 1, rx1392_restart
+    rx1392_cur."!cursor_debug"("START ", "assertion:sym<var>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1395_done
+    goto rxscan1395_scan
+  rxscan1395_loop:
+    ($P10) = rx1392_cur."from"()
+    inc $P10
+    set rx1392_pos, $P10
+    ge rx1392_pos, rx1392_eos, rxscan1395_done
+  rxscan1395_scan:
+    set_addr $I10, rxscan1395_loop
+    rx1392_cur."!mark_push"(0, rx1392_pos, $I10)
+  rxscan1395_done:
 .annotate 'line', 600
   # rx enumcharlist negate=0 zerowidth
-    ge rx1425_pos, rx1425_eos, rx1425_fail
-    sub $I10, rx1425_pos, rx1425_off
-    substr $S10, rx1425_tgt, $I10, 1
+    ge rx1392_pos, rx1392_eos, rx1392_fail
+    sub $I10, rx1392_pos, rx1392_off
+    substr $S10, rx1392_tgt, $I10, 1
     index $I11, "$@", $S10
-    lt $I11, 0, rx1425_fail
+    lt $I11, 0, rx1392_fail
   # rx subrule "LANG" subtype=capture negate=
-    rx1425_cur."!cursor_pos"(rx1425_pos)
-    $P10 = rx1425_cur."LANG"("MAIN", "variable")
-    unless $P10, rx1425_fail
-    rx1425_cur."!mark_push"(0, -1, 0, $P10)
+    rx1392_cur."!cursor_pos"(rx1392_pos)
+    $P10 = rx1392_cur."LANG"("MAIN", "variable")
+    unless $P10, rx1392_fail
+    rx1392_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("var")
-    rx1425_pos = $P10."pos"()
+    rx1392_pos = $P10."pos"()
 .annotate 'line', 599
   # rx pass
-    rx1425_cur."!cursor_pass"(rx1425_pos, "assertion:sym<var>")
-    rx1425_cur."!cursor_debug"("PASS  ", "assertion:sym<var>", " at pos=", rx1425_pos)
-    .return (rx1425_cur)
-  rx1425_fail:
+    rx1392_cur."!cursor_pass"(rx1392_pos, "assertion:sym<var>")
+    rx1392_cur."!cursor_debug"("PASS  ", "assertion:sym<var>", " at pos=", rx1392_pos)
+    .return (rx1392_cur)
+  rx1392_restart:
 .annotate 'line', 567
-    (rx1425_rep, rx1425_pos, $I10, $P10) = rx1425_cur."!mark_fail"(0)
-    lt rx1425_pos, -1, rx1425_done
-    eq rx1425_pos, -1, rx1425_fail
-    jump $I10
-  rx1425_done:
-    rx1425_cur."!cursor_fail"()
-    rx1425_cur."!cursor_debug"("FAIL  ", "assertion:sym<var>")
-    .return (rx1425_cur)
+    rx1392_cur."!cursor_debug"("NEXT ", "assertion:sym<var>")
+  rx1392_fail:
+    (rx1392_rep, rx1392_pos, $I10, $P10) = rx1392_cur."!mark_fail"(0)
+    lt rx1392_pos, -1, rx1392_done
+    eq rx1392_pos, -1, rx1392_fail
+    jump $I10
+  rx1392_done:
+    rx1392_cur."!cursor_fail"()
+    rx1392_cur."!cursor_debug"("FAIL  ", "assertion:sym<var>")
+    .return (rx1392_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__assertion:sym<var>"  :subid("367_1278500537.15927") :method
+.sub "!PREFIX__assertion:sym<var>"  :subid("367_1279529226.73787") :method
 .annotate 'line', 567
-    new $P1427, "ResizablePMCArray"
-    push $P1427, "$"
-    push $P1427, "@"
-    .return ($P1427)
+    new $P1394, "ResizablePMCArray"
+    push $P1394, "$"
+    push $P1394, "@"
+    .return ($P1394)
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "codeblock"  :subid("368_1278500537.15927") :method :outer("349_1278500537.15927")
+.sub "codeblock"  :subid("368_1279529226.73787") :method :outer("349_1279529226.73787")
 .annotate 'line', 567
-    .local string rx1430_tgt
-    .local int rx1430_pos
-    .local int rx1430_off
-    .local int rx1430_eos
-    .local int rx1430_rep
-    .local pmc rx1430_cur
-    (rx1430_cur, rx1430_pos, rx1430_tgt) = self."!cursor_start"()
-    rx1430_cur."!cursor_debug"("START ", "codeblock")
-    .lex unicode:"$\x{a2}", rx1430_cur
-    .local pmc match
-    .lex "$/", match
-    length rx1430_eos, rx1430_tgt
-    gt rx1430_pos, rx1430_eos, rx1430_done
-    set rx1430_off, 0
-    lt rx1430_pos, 2, rx1430_start
-    sub rx1430_off, rx1430_pos, 1
-    substr rx1430_tgt, rx1430_tgt, rx1430_off
-  rx1430_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan1434_done
-    goto rxscan1434_scan
-  rxscan1434_loop:
-    ($P10) = rx1430_cur."from"()
-    inc $P10
-    set rx1430_pos, $P10
-    ge rx1430_pos, rx1430_eos, rxscan1434_done
-  rxscan1434_scan:
-    set_addr $I10, rxscan1434_loop
-    rx1430_cur."!mark_push"(0, rx1430_pos, $I10)
-  rxscan1434_done:
+    .local string rx1397_tgt
+    .local int rx1397_pos
+    .local int rx1397_off
+    .local int rx1397_eos
+    .local int rx1397_rep
+    .local pmc rx1397_cur
+    (rx1397_cur, rx1397_pos, rx1397_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx1397_cur
+    .local pmc match
+    .lex "$/", match
+    length rx1397_eos, rx1397_tgt
+    gt rx1397_pos, rx1397_eos, rx1397_done
+    set rx1397_off, 0
+    lt rx1397_pos, 2, rx1397_start
+    sub rx1397_off, rx1397_pos, 1
+    substr rx1397_tgt, rx1397_tgt, rx1397_off
+  rx1397_start:
+    eq $I10, 1, rx1397_restart
+    rx1397_cur."!cursor_debug"("START ", "codeblock")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan1401_done
+    goto rxscan1401_scan
+  rxscan1401_loop:
+    ($P10) = rx1397_cur."from"()
+    inc $P10
+    set rx1397_pos, $P10
+    ge rx1397_pos, rx1397_eos, rxscan1401_done
+  rxscan1401_scan:
+    set_addr $I10, rxscan1401_loop
+    rx1397_cur."!mark_push"(0, rx1397_pos, $I10)
+  rxscan1401_done:
 .annotate 'line', 604
   # rx subrule "LANG" subtype=capture negate=
-    rx1430_cur."!cursor_pos"(rx1430_pos)
-    $P10 = rx1430_cur."LANG"("MAIN", "pblock")
-    unless $P10, rx1430_fail
-    rx1430_cur."!mark_push"(0, -1, 0, $P10)
+    rx1397_cur."!cursor_pos"(rx1397_pos)
+    $P10 = rx1397_cur."LANG"("MAIN", "pblock")
+    unless $P10, rx1397_fail
+    rx1397_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("block")
-    rx1430_pos = $P10."pos"()
+    rx1397_pos = $P10."pos"()
 .annotate 'line', 603
   # rx pass
-    rx1430_cur."!cursor_pass"(rx1430_pos, "codeblock")
-    rx1430_cur."!cursor_debug"("PASS  ", "codeblock", " at pos=", rx1430_pos)
-    .return (rx1430_cur)
-  rx1430_fail:
+    rx1397_cur."!cursor_pass"(rx1397_pos, "codeblock")
+    rx1397_cur."!cursor_debug"("PASS  ", "codeblock", " at pos=", rx1397_pos)
+    .return (rx1397_cur)
+  rx1397_restart:
 .annotate 'line', 567
-    (rx1430_rep, rx1430_pos, $I10, $P10) = rx1430_cur."!mark_fail"(0)
-    lt rx1430_pos, -1, rx1430_done
-    eq rx1430_pos, -1, rx1430_fail
-    jump $I10
-  rx1430_done:
-    rx1430_cur."!cursor_fail"()
-    rx1430_cur."!cursor_debug"("FAIL  ", "codeblock")
-    .return (rx1430_cur)
+    rx1397_cur."!cursor_debug"("NEXT ", "codeblock")
+  rx1397_fail:
+    (rx1397_rep, rx1397_pos, $I10, $P10) = rx1397_cur."!mark_fail"(0)
+    lt rx1397_pos, -1, rx1397_done
+    eq rx1397_pos, -1, rx1397_fail
+    jump $I10
+  rx1397_done:
+    rx1397_cur."!cursor_fail"()
+    rx1397_cur."!cursor_debug"("FAIL  ", "codeblock")
+    .return (rx1397_cur)
     .return ()
 .end
 
 
 .namespace ["NQP";"Regex"]
-.sub "!PREFIX__codeblock"  :subid("369_1278500537.15927") :method
+.sub "!PREFIX__codeblock"  :subid("369_1279529226.73787") :method
 .annotate 'line', 567
-    $P1432 = self."!PREFIX__!subrule"("LANG", "")
-    new $P1433, "ResizablePMCArray"
-    push $P1433, $P1432
-    .return ($P1433)
+    $P1399 = self."!PREFIX__!subrule"("LANG", "")
+    new $P1400, "ResizablePMCArray"
+    push $P1400, $P1399
+    .return ($P1400)
 .end
 
 
 .namespace ["NQP";"Grammar"]
-.sub "_block1436" :load :anon :subid("370_1278500537.15927")
+.sub "_block1403" :load :anon :subid("370_1279529226.73787")
 .annotate 'line', 4
-    .const 'Sub' $P1438 = "11_1278500537.15927" 
-    $P1439 = $P1438()
-    .return ($P1439)
+    .const 'Sub' $P1405 = "11_1279529226.73787" 
+    $P1406 = $P1405()
+    .return ($P1406)
 .end
 
 
 .namespace []
-.sub "_block1457" :load :anon :subid("371_1278500537.15927")
+.sub "_block1424" :load :anon :subid("371_1279529226.73787")
 .annotate 'line', 1
-    .const 'Sub' $P1459 = "10_1278500537.15927" 
-    $P1460 = $P1459()
-    .return ($P1460)
+    .const 'Sub' $P1426 = "10_1279529226.73787" 
+    $P1427 = $P1426()
+    .return ($P1427)
 .end
 
 ### .include 'gen/nqp-actions.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500542.82783")
+.sub "_block11"  :anon :subid("10_1279529234.12714")
 .annotate 'line', 0
     get_hll_global $P14, ["NQP";"Actions"], "_block13" 
     capture_lex $P14
@@ -17834,15 +18512,15 @@
     $P2447 = $P14()
 .annotate 'line', 1
     .return ($P2447)
-    .const 'Sub' $P2449 = "143_1278500542.82783" 
+    .const 'Sub' $P2449 = "143_1279529234.12714" 
     .return ($P2449)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post144") :outer("10_1278500542.82783")
+.sub "" :load :init :subid("post144") :outer("10_1279529234.12714")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500542.82783" 
+    .const 'Sub' $P12 = "10_1279529234.12714" 
     .local pmc block
     set block, $P12
     $P2452 = get_root_global ["parrot"], "P6metaclass"
@@ -17851,217 +18529,217 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block13"  :subid("11_1278500542.82783") :outer("10_1278500542.82783")
+.sub "_block13"  :subid("11_1279529234.12714") :outer("10_1279529234.12714")
 .annotate 'line', 3
-    .const 'Sub' $P2443 = "142_1278500542.82783" 
+    .const 'Sub' $P2443 = "142_1279529234.12714" 
     capture_lex $P2443
     get_hll_global $P2326, ["NQP";"RegexActions"], "_block2325" 
     capture_lex $P2326
-    .const 'Sub' $P2315 = "132_1278500542.82783" 
+    .const 'Sub' $P2315 = "132_1279529234.12714" 
     capture_lex $P2315
-    .const 'Sub' $P2308 = "131_1278500542.82783" 
+    .const 'Sub' $P2308 = "131_1279529234.12714" 
     capture_lex $P2308
-    .const 'Sub' $P2301 = "130_1278500542.82783" 
+    .const 'Sub' $P2301 = "130_1279529234.12714" 
     capture_lex $P2301
-    .const 'Sub' $P2294 = "129_1278500542.82783" 
+    .const 'Sub' $P2294 = "129_1279529234.12714" 
     capture_lex $P2294
-    .const 'Sub' $P2281 = "128_1278500542.82783" 
+    .const 'Sub' $P2281 = "128_1279529234.12714" 
     capture_lex $P2281
-    .const 'Sub' $P2271 = "127_1278500542.82783" 
+    .const 'Sub' $P2271 = "127_1279529234.12714" 
     capture_lex $P2271
-    .const 'Sub' $P2261 = "126_1278500542.82783" 
+    .const 'Sub' $P2261 = "126_1279529234.12714" 
     capture_lex $P2261
-    .const 'Sub' $P2251 = "125_1278500542.82783" 
+    .const 'Sub' $P2251 = "125_1279529234.12714" 
     capture_lex $P2251
-    .const 'Sub' $P2244 = "124_1278500542.82783" 
+    .const 'Sub' $P2244 = "124_1279529234.12714" 
     capture_lex $P2244
-    .const 'Sub' $P2230 = "123_1278500542.82783" 
+    .const 'Sub' $P2230 = "123_1279529234.12714" 
     capture_lex $P2230
-    .const 'Sub' $P2220 = "122_1278500542.82783" 
+    .const 'Sub' $P2220 = "122_1279529234.12714" 
     capture_lex $P2220
-    .const 'Sub' $P2183 = "121_1278500542.82783" 
+    .const 'Sub' $P2183 = "121_1279529234.12714" 
     capture_lex $P2183
-    .const 'Sub' $P2169 = "120_1278500542.82783" 
+    .const 'Sub' $P2169 = "120_1279529234.12714" 
     capture_lex $P2169
-    .const 'Sub' $P2159 = "119_1278500542.82783" 
+    .const 'Sub' $P2159 = "119_1279529234.12714" 
     capture_lex $P2159
-    .const 'Sub' $P2149 = "118_1278500542.82783" 
+    .const 'Sub' $P2149 = "118_1279529234.12714" 
     capture_lex $P2149
-    .const 'Sub' $P2139 = "117_1278500542.82783" 
+    .const 'Sub' $P2139 = "117_1279529234.12714" 
     capture_lex $P2139
-    .const 'Sub' $P2129 = "116_1278500542.82783" 
+    .const 'Sub' $P2129 = "116_1279529234.12714" 
     capture_lex $P2129
-    .const 'Sub' $P2119 = "115_1278500542.82783" 
+    .const 'Sub' $P2119 = "115_1279529234.12714" 
     capture_lex $P2119
-    .const 'Sub' $P2091 = "114_1278500542.82783" 
+    .const 'Sub' $P2091 = "114_1279529234.12714" 
     capture_lex $P2091
-    .const 'Sub' $P2074 = "113_1278500542.82783" 
+    .const 'Sub' $P2074 = "113_1279529234.12714" 
     capture_lex $P2074
-    .const 'Sub' $P2064 = "112_1278500542.82783" 
+    .const 'Sub' $P2064 = "112_1279529234.12714" 
     capture_lex $P2064
-    .const 'Sub' $P2051 = "111_1278500542.82783" 
+    .const 'Sub' $P2051 = "111_1279529234.12714" 
     capture_lex $P2051
-    .const 'Sub' $P2038 = "110_1278500542.82783" 
+    .const 'Sub' $P2038 = "110_1279529234.12714" 
     capture_lex $P2038
-    .const 'Sub' $P2025 = "109_1278500542.82783" 
+    .const 'Sub' $P2025 = "109_1279529234.12714" 
     capture_lex $P2025
-    .const 'Sub' $P2015 = "108_1278500542.82783" 
+    .const 'Sub' $P2015 = "108_1279529234.12714" 
     capture_lex $P2015
-    .const 'Sub' $P1986 = "107_1278500542.82783" 
+    .const 'Sub' $P1986 = "107_1279529234.12714" 
     capture_lex $P1986
-    .const 'Sub' $P1962 = "106_1278500542.82783" 
+    .const 'Sub' $P1962 = "106_1279529234.12714" 
     capture_lex $P1962
-    .const 'Sub' $P1952 = "105_1278500542.82783" 
+    .const 'Sub' $P1952 = "105_1279529234.12714" 
     capture_lex $P1952
-    .const 'Sub' $P1942 = "104_1278500542.82783" 
+    .const 'Sub' $P1942 = "104_1279529234.12714" 
     capture_lex $P1942
-    .const 'Sub' $P1915 = "103_1278500542.82783" 
+    .const 'Sub' $P1915 = "103_1279529234.12714" 
     capture_lex $P1915
-    .const 'Sub' $P1897 = "102_1278500542.82783" 
+    .const 'Sub' $P1897 = "102_1279529234.12714" 
     capture_lex $P1897
-    .const 'Sub' $P1887 = "101_1278500542.82783" 
+    .const 'Sub' $P1887 = "101_1279529234.12714" 
     capture_lex $P1887
-    .const 'Sub' $P1783 = "98_1278500542.82783" 
+    .const 'Sub' $P1783 = "98_1279529234.12714" 
     capture_lex $P1783
-    .const 'Sub' $P1773 = "97_1278500542.82783" 
+    .const 'Sub' $P1773 = "97_1279529234.12714" 
     capture_lex $P1773
-    .const 'Sub' $P1744 = "96_1278500542.82783" 
+    .const 'Sub' $P1744 = "96_1279529234.12714" 
     capture_lex $P1744
-    .const 'Sub' $P1702 = "95_1278500542.82783" 
+    .const 'Sub' $P1702 = "95_1279529234.12714" 
     capture_lex $P1702
-    .const 'Sub' $P1686 = "94_1278500542.82783" 
+    .const 'Sub' $P1686 = "94_1279529234.12714" 
     capture_lex $P1686
-    .const 'Sub' $P1677 = "93_1278500542.82783" 
+    .const 'Sub' $P1677 = "93_1279529234.12714" 
     capture_lex $P1677
-    .const 'Sub' $P1645 = "92_1278500542.82783" 
+    .const 'Sub' $P1645 = "92_1279529234.12714" 
     capture_lex $P1645
-    .const 'Sub' $P1546 = "89_1278500542.82783" 
+    .const 'Sub' $P1546 = "89_1279529234.12714" 
     capture_lex $P1546
-    .const 'Sub' $P1529 = "88_1278500542.82783" 
+    .const 'Sub' $P1529 = "88_1279529234.12714" 
     capture_lex $P1529
-    .const 'Sub' $P1509 = "87_1278500542.82783" 
+    .const 'Sub' $P1509 = "87_1279529234.12714" 
     capture_lex $P1509
-    .const 'Sub' $P1397 = "84_1278500542.82783" 
+    .const 'Sub' $P1397 = "84_1279529234.12714" 
     capture_lex $P1397
-    .const 'Sub' $P1340 = "80_1278500542.82783" 
+    .const 'Sub' $P1340 = "80_1279529234.12714" 
     capture_lex $P1340
-    .const 'Sub' $P1300 = "78_1278500542.82783" 
+    .const 'Sub' $P1300 = "78_1279529234.12714" 
     capture_lex $P1300
-    .const 'Sub' $P1250 = "76_1278500542.82783" 
+    .const 'Sub' $P1250 = "76_1279529234.12714" 
     capture_lex $P1250
-    .const 'Sub' $P1240 = "75_1278500542.82783" 
+    .const 'Sub' $P1240 = "75_1279529234.12714" 
     capture_lex $P1240
-    .const 'Sub' $P1230 = "74_1278500542.82783" 
+    .const 'Sub' $P1230 = "74_1279529234.12714" 
     capture_lex $P1230
-    .const 'Sub' $P1159 = "72_1278500542.82783" 
+    .const 'Sub' $P1159 = "72_1279529234.12714" 
     capture_lex $P1159
-    .const 'Sub' $P1149 = "71_1278500542.82783" 
+    .const 'Sub' $P1149 = "71_1279529234.12714" 
     capture_lex $P1149
-    .const 'Sub' $P1132 = "70_1278500542.82783" 
+    .const 'Sub' $P1132 = "70_1279529234.12714" 
     capture_lex $P1132
-    .const 'Sub' $P1115 = "69_1278500542.82783" 
+    .const 'Sub' $P1115 = "69_1279529234.12714" 
     capture_lex $P1115
-    .const 'Sub' $P1098 = "68_1278500542.82783" 
+    .const 'Sub' $P1098 = "68_1279529234.12714" 
     capture_lex $P1098
-    .const 'Sub' $P1088 = "67_1278500542.82783" 
+    .const 'Sub' $P1088 = "67_1279529234.12714" 
     capture_lex $P1088
-    .const 'Sub' $P1078 = "66_1278500542.82783" 
+    .const 'Sub' $P1078 = "66_1279529234.12714" 
     capture_lex $P1078
-    .const 'Sub' $P1068 = "65_1278500542.82783" 
+    .const 'Sub' $P1068 = "65_1279529234.12714" 
     capture_lex $P1068
-    .const 'Sub' $P1044 = "64_1278500542.82783" 
+    .const 'Sub' $P1044 = "64_1279529234.12714" 
     capture_lex $P1044
-    .const 'Sub' $P991 = "63_1278500542.82783" 
+    .const 'Sub' $P991 = "63_1279529234.12714" 
     capture_lex $P991
-    .const 'Sub' $P981 = "62_1278500542.82783" 
+    .const 'Sub' $P981 = "62_1279529234.12714" 
     capture_lex $P981
-    .const 'Sub' $P892 = "60_1278500542.82783" 
+    .const 'Sub' $P892 = "60_1279529234.12714" 
     capture_lex $P892
-    .const 'Sub' $P866 = "59_1278500542.82783" 
+    .const 'Sub' $P866 = "59_1279529234.12714" 
     capture_lex $P866
-    .const 'Sub' $P850 = "58_1278500542.82783" 
+    .const 'Sub' $P850 = "58_1279529234.12714" 
     capture_lex $P850
-    .const 'Sub' $P840 = "57_1278500542.82783" 
+    .const 'Sub' $P840 = "57_1279529234.12714" 
     capture_lex $P840
-    .const 'Sub' $P830 = "56_1278500542.82783" 
+    .const 'Sub' $P830 = "56_1279529234.12714" 
     capture_lex $P830
-    .const 'Sub' $P820 = "55_1278500542.82783" 
+    .const 'Sub' $P820 = "55_1279529234.12714" 
     capture_lex $P820
-    .const 'Sub' $P810 = "54_1278500542.82783" 
+    .const 'Sub' $P810 = "54_1279529234.12714" 
     capture_lex $P810
-    .const 'Sub' $P800 = "53_1278500542.82783" 
+    .const 'Sub' $P800 = "53_1279529234.12714" 
     capture_lex $P800
-    .const 'Sub' $P790 = "52_1278500542.82783" 
+    .const 'Sub' $P790 = "52_1279529234.12714" 
     capture_lex $P790
-    .const 'Sub' $P780 = "51_1278500542.82783" 
+    .const 'Sub' $P780 = "51_1279529234.12714" 
     capture_lex $P780
-    .const 'Sub' $P770 = "50_1278500542.82783" 
+    .const 'Sub' $P770 = "50_1279529234.12714" 
     capture_lex $P770
-    .const 'Sub' $P760 = "49_1278500542.82783" 
+    .const 'Sub' $P760 = "49_1279529234.12714" 
     capture_lex $P760
-    .const 'Sub' $P750 = "48_1278500542.82783" 
+    .const 'Sub' $P750 = "48_1279529234.12714" 
     capture_lex $P750
-    .const 'Sub' $P740 = "47_1278500542.82783" 
+    .const 'Sub' $P740 = "47_1279529234.12714" 
     capture_lex $P740
-    .const 'Sub' $P730 = "46_1278500542.82783" 
+    .const 'Sub' $P730 = "46_1279529234.12714" 
     capture_lex $P730
-    .const 'Sub' $P720 = "45_1278500542.82783" 
+    .const 'Sub' $P720 = "45_1279529234.12714" 
     capture_lex $P720
-    .const 'Sub' $P702 = "44_1278500542.82783" 
+    .const 'Sub' $P702 = "44_1279529234.12714" 
     capture_lex $P702
-    .const 'Sub' $P667 = "43_1278500542.82783" 
+    .const 'Sub' $P667 = "43_1279529234.12714" 
     capture_lex $P667
-    .const 'Sub' $P651 = "42_1278500542.82783" 
+    .const 'Sub' $P651 = "42_1279529234.12714" 
     capture_lex $P651
-    .const 'Sub' $P630 = "41_1278500542.82783" 
+    .const 'Sub' $P630 = "41_1279529234.12714" 
     capture_lex $P630
-    .const 'Sub' $P610 = "40_1278500542.82783" 
+    .const 'Sub' $P610 = "40_1279529234.12714" 
     capture_lex $P610
-    .const 'Sub' $P597 = "39_1278500542.82783" 
+    .const 'Sub' $P597 = "39_1279529234.12714" 
     capture_lex $P597
-    .const 'Sub' $P571 = "38_1278500542.82783" 
+    .const 'Sub' $P571 = "38_1279529234.12714" 
     capture_lex $P571
-    .const 'Sub' $P535 = "37_1278500542.82783" 
+    .const 'Sub' $P535 = "37_1279529234.12714" 
     capture_lex $P535
-    .const 'Sub' $P518 = "36_1278500542.82783" 
+    .const 'Sub' $P518 = "36_1279529234.12714" 
     capture_lex $P518
-    .const 'Sub' $P504 = "35_1278500542.82783" 
+    .const 'Sub' $P504 = "35_1279529234.12714" 
     capture_lex $P504
-    .const 'Sub' $P451 = "33_1278500542.82783" 
+    .const 'Sub' $P451 = "33_1279529234.12714" 
     capture_lex $P451
-    .const 'Sub' $P440 = "32_1278500542.82783" 
+    .const 'Sub' $P440 = "32_1279529234.12714" 
     capture_lex $P440
-    .const 'Sub' $P427 = "31_1278500542.82783" 
+    .const 'Sub' $P427 = "31_1279529234.12714" 
     capture_lex $P427
-    .const 'Sub' $P407 = "30_1278500542.82783" 
+    .const 'Sub' $P407 = "30_1279529234.12714" 
     capture_lex $P407
-    .const 'Sub' $P397 = "29_1278500542.82783" 
+    .const 'Sub' $P397 = "29_1279529234.12714" 
     capture_lex $P397
-    .const 'Sub' $P387 = "28_1278500542.82783" 
+    .const 'Sub' $P387 = "28_1279529234.12714" 
     capture_lex $P387
-    .const 'Sub' $P371 = "27_1278500542.82783" 
+    .const 'Sub' $P371 = "27_1279529234.12714" 
     capture_lex $P371
-    .const 'Sub' $P288 = "25_1278500542.82783" 
+    .const 'Sub' $P288 = "25_1279529234.12714" 
     capture_lex $P288
-    .const 'Sub' $P245 = "23_1278500542.82783" 
+    .const 'Sub' $P245 = "23_1279529234.12714" 
     capture_lex $P245
-    .const 'Sub' $P213 = "22_1278500542.82783" 
+    .const 'Sub' $P213 = "22_1279529234.12714" 
     capture_lex $P213
-    .const 'Sub' $P180 = "21_1278500542.82783" 
+    .const 'Sub' $P180 = "21_1279529234.12714" 
     capture_lex $P180
-    .const 'Sub' $P170 = "20_1278500542.82783" 
+    .const 'Sub' $P170 = "20_1279529234.12714" 
     capture_lex $P170
-    .const 'Sub' $P151 = "19_1278500542.82783" 
+    .const 'Sub' $P151 = "19_1279529234.12714" 
     capture_lex $P151
-    .const 'Sub' $P100 = "18_1278500542.82783" 
+    .const 'Sub' $P100 = "18_1279529234.12714" 
     capture_lex $P100
-    .const 'Sub' $P84 = "17_1278500542.82783" 
+    .const 'Sub' $P84 = "17_1279529234.12714" 
     capture_lex $P84
-    .const 'Sub' $P63 = "16_1278500542.82783" 
+    .const 'Sub' $P63 = "16_1279529234.12714" 
     capture_lex $P63
-    .const 'Sub' $P27 = "13_1278500542.82783" 
+    .const 'Sub' $P27 = "13_1279529234.12714" 
     capture_lex $P27
-    .const 'Sub' $P16 = "12_1278500542.82783" 
+    .const 'Sub' $P16 = "12_1279529234.12714" 
     capture_lex $P16
     get_global $P15, "@BLOCK"
     unless_null $P15, vivify_147
@@ -18069,27 +18747,27 @@
     set_global "@BLOCK", $P15
   vivify_147:
 .annotate 'line', 9
-    .const 'Sub' $P16 = "12_1278500542.82783" 
+    .const 'Sub' $P16 = "12_1279529234.12714" 
     newclosure $P26, $P16
     .lex "xblock_immediate", $P26
 .annotate 'line', 14
-    .const 'Sub' $P27 = "13_1278500542.82783" 
+    .const 'Sub' $P27 = "13_1279529234.12714" 
     newclosure $P62, $P27
     .lex "block_immediate", $P62
 .annotate 'line', 24
-    .const 'Sub' $P63 = "16_1278500542.82783" 
+    .const 'Sub' $P63 = "16_1279529234.12714" 
     newclosure $P83, $P63
     .lex "vivitype", $P83
 .annotate 'line', 43
-    .const 'Sub' $P84 = "17_1278500542.82783" 
+    .const 'Sub' $P84 = "17_1279529234.12714" 
     newclosure $P99, $P84
     .lex "colonpair_str", $P99
 .annotate 'line', 223
-    .const 'Sub' $P100 = "18_1278500542.82783" 
+    .const 'Sub' $P100 = "18_1279529234.12714" 
     newclosure $P150, $P100
     .lex "push_block_handler", $P150
 .annotate 'line', 832
-    .const 'Sub' $P151 = "19_1278500542.82783" 
+    .const 'Sub' $P151 = "19_1279529234.12714" 
     newclosure $P165, $P151
     .lex "control", $P165
 .annotate 'line', 3
@@ -18116,19 +18794,19 @@
     $P2437 = $P2326()
 .annotate 'line', 3
     .return ($P2437)
-    .const 'Sub' $P2439 = "141_1278500542.82783" 
+    .const 'Sub' $P2439 = "141_1279529234.12714" 
     .return ($P2439)
 .end
 
 
 .namespace ["NQP";"Actions"]
-.sub "" :load :init :subid("post145") :outer("11_1278500542.82783")
+.sub "" :load :init :subid("post145") :outer("11_1279529234.12714")
 .annotate 'line', 3
     get_hll_global $P14, ["NQP";"Actions"], "_block13" 
     .local pmc block
     set block, $P14
 .annotate 'line', 5
-    .const 'Sub' $P2443 = "142_1278500542.82783" 
+    .const 'Sub' $P2443 = "142_1279529234.12714" 
     capture_lex $P2443
     $P2443()
     $P2446 = get_root_global ["parrot"], "P6metaclass"
@@ -18137,7 +18815,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block2442"  :anon :subid("142_1278500542.82783") :outer("11_1278500542.82783")
+.sub "_block2442"  :anon :subid("142_1279529234.12714") :outer("11_1279529234.12714")
 .annotate 'line', 6
     get_global $P2444, "@BLOCK"
     unless_null $P2444, vivify_146
@@ -18153,7 +18831,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "xblock_immediate"  :subid("12_1278500542.82783") :outer("11_1278500542.82783")
+.sub "xblock_immediate"  :subid("12_1279529234.12714") :outer("11_1279529234.12714")
     .param pmc param_19
 .annotate 'line', 9
     new $P18, 'ExceptionHandler'
@@ -18190,10 +18868,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "block_immediate"  :subid("13_1278500542.82783") :outer("11_1278500542.82783")
+.sub "block_immediate"  :subid("13_1279529234.12714") :outer("11_1279529234.12714")
     .param pmc param_30
 .annotate 'line', 14
-    .const 'Sub' $P40 = "14_1278500542.82783" 
+    .const 'Sub' $P40 = "14_1279529234.12714" 
     capture_lex $P40
     new $P29, 'ExceptionHandler'
     set_addr $P29, control_28
@@ -18215,7 +18893,7 @@
     set $P33, $P38
   unless_34_end:
     if $P33, unless_32_end
-    .const 'Sub' $P40 = "14_1278500542.82783" 
+    .const 'Sub' $P40 = "14_1279529234.12714" 
     capture_lex $P40
     $P40()
   unless_32_end:
@@ -18232,9 +18910,9 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "_block39"  :anon :subid("14_1278500542.82783") :outer("13_1278500542.82783")
+.sub "_block39"  :anon :subid("14_1279529234.12714") :outer("13_1279529234.12714")
 .annotate 'line', 16
-    .const 'Sub' $P51 = "15_1278500542.82783" 
+    .const 'Sub' $P51 = "15_1279529234.12714" 
     capture_lex $P51
 .annotate 'line', 17
     new $P41, "Undef"
@@ -18257,7 +18935,7 @@
     unless $P45, loop56_done
     shift $P49, $P45
   loop56_redo:
-    .const 'Sub' $P51 = "15_1278500542.82783" 
+    .const 'Sub' $P51 = "15_1279529234.12714" 
     capture_lex $P51
     $P51($P49)
   loop56_next:
@@ -18280,7 +18958,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block50"  :anon :subid("15_1278500542.82783") :outer("14_1278500542.82783")
+.sub "_block50"  :anon :subid("15_1279529234.12714") :outer("14_1279529234.12714")
     .param pmc param_52
 .annotate 'line', 18
     .lex "$_", param_52
@@ -18293,7 +18971,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "vivitype"  :subid("16_1278500542.82783") :outer("11_1278500542.82783")
+.sub "vivitype"  :subid("16_1279529234.12714") :outer("11_1279529234.12714")
     .param pmc param_66
 .annotate 'line', 24
     new $P65, 'ExceptionHandler'
@@ -18342,7 +19020,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "colonpair_str"  :subid("17_1278500542.82783") :outer("11_1278500542.82783")
+.sub "colonpair_str"  :subid("17_1279529234.12714") :outer("11_1279529234.12714")
     .param pmc param_87
 .annotate 'line', 43
     new $P86, 'ExceptionHandler'
@@ -18381,7 +19059,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "push_block_handler"  :subid("18_1278500542.82783") :outer("11_1278500542.82783")
+.sub "push_block_handler"  :subid("18_1279529234.12714") :outer("11_1279529234.12714")
     .param pmc param_103
     .param pmc param_104
 .annotate 'line', 223
@@ -18499,7 +19177,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "control"  :subid("19_1278500542.82783") :outer("11_1278500542.82783")
+.sub "control"  :subid("19_1279529234.12714") :outer("11_1279529234.12714")
     .param pmc param_154
     .param pmc param_155
 .annotate 'line', 832
@@ -18532,7 +19210,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "TOP"  :subid("20_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "TOP"  :subid("20_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_173
 .annotate 'line', 33
     new $P172, 'ExceptionHandler'
@@ -18563,7 +19241,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "deflongname"  :subid("21_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "deflongname"  :subid("21_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_183
 .annotate 'line', 35
     new $P182, 'ExceptionHandler'
@@ -18653,7 +19331,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "comp_unit"  :subid("22_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "comp_unit"  :subid("22_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_216
 .annotate 'line', 49
     new $P215, 'ExceptionHandler'
@@ -18728,10 +19406,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statementlist"  :subid("23_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statementlist"  :subid("23_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_248
 .annotate 'line', 76
-    .const 'Sub' $P262 = "24_1278500542.82783" 
+    .const 'Sub' $P262 = "24_1279529234.12714" 
     capture_lex $P262
     new $P247, 'ExceptionHandler'
     set_addr $P247, control_246
@@ -18776,7 +19454,7 @@
     unless $P256, loop281_done
     shift $P260, $P256
   loop281_redo:
-    .const 'Sub' $P262 = "24_1278500542.82783" 
+    .const 'Sub' $P262 = "24_1279529234.12714" 
     capture_lex $P262
     $P262($P260)
   loop281_next:
@@ -18806,7 +19484,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block261"  :anon :subid("24_1278500542.82783") :outer("23_1278500542.82783")
+.sub "_block261"  :anon :subid("24_1279529234.12714") :outer("23_1279529234.12714")
     .param pmc param_264
 .annotate 'line', 80
     new $P263, "Undef"
@@ -18861,12 +19539,12 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement"  :subid("25_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement"  :subid("25_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_291
     .param pmc param_292 :optional
     .param int has_param_292 :opt_flag
 .annotate 'line', 89
-    .const 'Sub' $P300 = "26_1278500542.82783" 
+    .const 'Sub' $P300 = "26_1279529234.12714" 
     capture_lex $P300
     new $P290, 'ExceptionHandler'
     set_addr $P290, control_289
@@ -18925,7 +19603,7 @@
     goto if_296_end
   if_296:
 .annotate 'line', 91
-    .const 'Sub' $P300 = "26_1278500542.82783" 
+    .const 'Sub' $P300 = "26_1279529234.12714" 
     capture_lex $P300
     $P300()
   if_296_end:
@@ -18944,7 +19622,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block299"  :anon :subid("26_1278500542.82783") :outer("25_1278500542.82783")
+.sub "_block299"  :anon :subid("26_1279529234.12714") :outer("25_1279529234.12714")
 .annotate 'line', 92
     new $P301, "Undef"
     .lex "$mc", $P301
@@ -19117,7 +19795,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "xblock"  :subid("27_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "xblock"  :subid("27_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_374
 .annotate 'line', 117
     new $P373, 'ExceptionHandler'
@@ -19162,7 +19840,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "pblock"  :subid("28_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "pblock"  :subid("28_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_390
 .annotate 'line', 121
     new $P389, 'ExceptionHandler'
@@ -19195,7 +19873,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "block"  :subid("29_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "block"  :subid("29_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_400
 .annotate 'line', 125
     new $P399, 'ExceptionHandler'
@@ -19228,7 +19906,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "blockoid"  :subid("30_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "blockoid"  :subid("30_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_410
 .annotate 'line', 129
     new $P409, 'ExceptionHandler'
@@ -19285,7 +19963,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "newpad"  :subid("31_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "newpad"  :subid("31_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_430
 .annotate 'line', 138
     new $P429, 'ExceptionHandler'
@@ -19321,7 +19999,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "outerctx"  :subid("32_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "outerctx"  :subid("32_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_443
 .annotate 'line', 143
     new $P442, 'ExceptionHandler'
@@ -19361,10 +20039,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<if>"  :subid("33_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<if>"  :subid("33_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_454
 .annotate 'line', 150
-    .const 'Sub' $P482 = "34_1278500542.82783" 
+    .const 'Sub' $P482 = "34_1279529234.12714" 
     capture_lex $P482
     new $P453, 'ExceptionHandler'
     set_addr $P453, control_452
@@ -19449,7 +20127,7 @@
     isgt $I480, $N479, 0.0
     unless $I480, loop497_done
   loop497_redo:
-    .const 'Sub' $P482 = "34_1278500542.82783" 
+    .const 'Sub' $P482 = "34_1279529234.12714" 
     capture_lex $P482
     $P482()
   loop497_next:
@@ -19477,7 +20155,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block481"  :anon :subid("34_1278500542.82783") :outer("33_1278500542.82783")
+.sub "_block481"  :anon :subid("34_1279529234.12714") :outer("33_1279529234.12714")
 .annotate 'line', 159
     new $P483, "Undef"
     .lex "$else", $P483
@@ -19517,7 +20195,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<unless>"  :subid("35_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<unless>"  :subid("35_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_507
 .annotate 'line', 166
     new $P506, 'ExceptionHandler'
@@ -19559,7 +20237,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<while>"  :subid("36_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<while>"  :subid("36_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_521
 .annotate 'line', 172
     new $P520, 'ExceptionHandler'
@@ -19610,7 +20288,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<repeat>"  :subid("37_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<repeat>"  :subid("37_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_538
 .annotate 'line', 178
     new $P537, 'ExceptionHandler'
@@ -19711,7 +20389,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<for>"  :subid("38_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<for>"  :subid("38_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_574
 .annotate 'line', 192
     new $P573, 'ExceptionHandler'
@@ -19792,7 +20470,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<return>"  :subid("39_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<return>"  :subid("39_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_600
 .annotate 'line', 205
     new $P599, 'ExceptionHandler'
@@ -19828,7 +20506,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<CATCH>"  :subid("40_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<CATCH>"  :subid("40_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_613
 .annotate 'line', 209
     new $P612, 'ExceptionHandler'
@@ -19887,7 +20565,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_control:sym<CONTROL>"  :subid("41_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_control:sym<CONTROL>"  :subid("41_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_633
 .annotate 'line', 216
     new $P632, 'ExceptionHandler'
@@ -19946,7 +20624,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_prefix:sym<INIT>"  :subid("42_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_prefix:sym<INIT>"  :subid("42_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_654
 .annotate 'line', 260
     new $P653, 'ExceptionHandler'
@@ -19993,7 +20671,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_prefix:sym<try>"  :subid("43_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_prefix:sym<try>"  :subid("43_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_670
 .annotate 'line', 265
     new $P669, 'ExceptionHandler'
@@ -20071,7 +20749,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "blorst"  :subid("44_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "blorst"  :subid("44_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_705
 .annotate 'line', 288
     new $P704, 'ExceptionHandler'
@@ -20131,7 +20809,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_mod_cond:sym<if>"  :subid("45_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_mod_cond:sym<if>"  :subid("45_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_723
 .annotate 'line', 296
     new $P722, 'ExceptionHandler'
@@ -20162,7 +20840,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_mod_cond:sym<unless>"  :subid("46_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_mod_cond:sym<unless>"  :subid("46_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_733
 .annotate 'line', 297
     new $P732, 'ExceptionHandler'
@@ -20193,7 +20871,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_mod_loop:sym<while>"  :subid("47_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_mod_loop:sym<while>"  :subid("47_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_743
 .annotate 'line', 299
     new $P742, 'ExceptionHandler'
@@ -20224,7 +20902,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "statement_mod_loop:sym<until>"  :subid("48_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "statement_mod_loop:sym<until>"  :subid("48_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_753
 .annotate 'line', 300
     new $P752, 'ExceptionHandler'
@@ -20255,7 +20933,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<fatarrow>"  :subid("49_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<fatarrow>"  :subid("49_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_763
 .annotate 'line', 304
     new $P762, 'ExceptionHandler'
@@ -20286,7 +20964,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<colonpair>"  :subid("50_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<colonpair>"  :subid("50_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_773
 .annotate 'line', 305
     new $P772, 'ExceptionHandler'
@@ -20317,7 +20995,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<variable>"  :subid("51_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<variable>"  :subid("51_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_783
 .annotate 'line', 306
     new $P782, 'ExceptionHandler'
@@ -20348,7 +21026,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<package_declarator>"  :subid("52_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<package_declarator>"  :subid("52_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_793
 .annotate 'line', 307
     new $P792, 'ExceptionHandler'
@@ -20379,7 +21057,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<scope_declarator>"  :subid("53_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<scope_declarator>"  :subid("53_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_803
 .annotate 'line', 308
     new $P802, 'ExceptionHandler'
@@ -20410,7 +21088,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<routine_declarator>"  :subid("54_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<routine_declarator>"  :subid("54_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_813
 .annotate 'line', 309
     new $P812, 'ExceptionHandler'
@@ -20441,7 +21119,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<regex_declarator>"  :subid("55_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<regex_declarator>"  :subid("55_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_823
 .annotate 'line', 310
     new $P822, 'ExceptionHandler'
@@ -20472,7 +21150,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<statement_prefix>"  :subid("56_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<statement_prefix>"  :subid("56_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_833
 .annotate 'line', 311
     new $P832, 'ExceptionHandler'
@@ -20503,7 +21181,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<lambda>"  :subid("57_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<lambda>"  :subid("57_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_843
 .annotate 'line', 312
     new $P842, 'ExceptionHandler'
@@ -20534,7 +21212,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "fatarrow"  :subid("58_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "fatarrow"  :subid("58_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_853
 .annotate 'line', 314
     new $P852, 'ExceptionHandler'
@@ -20584,7 +21262,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "colonpair"  :subid("59_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "colonpair"  :subid("59_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_869
 .annotate 'line', 320
     new $P868, 'ExceptionHandler'
@@ -20666,10 +21344,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "variable"  :subid("60_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "variable"  :subid("60_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_895
 .annotate 'line', 328
-    .const 'Sub' $P908 = "61_1278500542.82783" 
+    .const 'Sub' $P908 = "61_1279529234.12714" 
     capture_lex $P908
     new $P894, 'ExceptionHandler'
     set_addr $P894, control_893
@@ -20693,7 +21371,7 @@
   vivify_325:
     if $P900, if_898
 .annotate 'line', 334
-    .const 'Sub' $P908 = "61_1278500542.82783" 
+    .const 'Sub' $P908 = "61_1279529234.12714" 
     capture_lex $P908
     $P908()
     goto if_898_end
@@ -20730,7 +21408,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block907"  :anon :subid("61_1278500542.82783") :outer("60_1278500542.82783")
+.sub "_block907"  :anon :subid("61_1279529234.12714") :outer("60_1279529234.12714")
 .annotate 'line', 335
     $P909 = root_new ['parrot';'ResizablePMCArray']
     .lex "@name", $P909
@@ -20900,7 +21578,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "package_declarator:sym<module>"  :subid("62_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "package_declarator:sym<module>"  :subid("62_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_984
 .annotate 'line', 366
     new $P983, 'ExceptionHandler'
@@ -20931,7 +21609,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "package_declarator:sym<class>"  :subid("63_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "package_declarator:sym<class>"  :subid("63_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_994
 .annotate 'line', 367
     new $P993, 'ExceptionHandler'
@@ -21089,7 +21767,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "package_def"  :subid("64_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "package_def"  :subid("64_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1047
 .annotate 'line', 390
     new $P1046, 'ExceptionHandler'
@@ -21168,7 +21846,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "scope_declarator:sym<my>"  :subid("65_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "scope_declarator:sym<my>"  :subid("65_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1071
 .annotate 'line', 397
     new $P1070, 'ExceptionHandler'
@@ -21199,7 +21877,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "scope_declarator:sym<our>"  :subid("66_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "scope_declarator:sym<our>"  :subid("66_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1081
 .annotate 'line', 398
     new $P1080, 'ExceptionHandler'
@@ -21230,7 +21908,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "scope_declarator:sym<has>"  :subid("67_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "scope_declarator:sym<has>"  :subid("67_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1091
 .annotate 'line', 399
     new $P1090, 'ExceptionHandler'
@@ -21261,7 +21939,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "scoped"  :subid("68_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "scoped"  :subid("68_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1101
 .annotate 'line', 401
     new $P1100, 'ExceptionHandler'
@@ -21320,7 +21998,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "declarator"  :subid("69_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "declarator"  :subid("69_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1118
 .annotate 'line', 407
     new $P1117, 'ExceptionHandler'
@@ -21379,7 +22057,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "multi_declarator:sym<multi>"  :subid("70_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "multi_declarator:sym<multi>"  :subid("70_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1135
 .annotate 'line', 413
     new $P1134, 'ExceptionHandler'
@@ -21433,7 +22111,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "multi_declarator:sym<null>"  :subid("71_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "multi_declarator:sym<null>"  :subid("71_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1152
 .annotate 'line', 414
     new $P1151, 'ExceptionHandler'
@@ -21464,10 +22142,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "variable_declarator"  :subid("72_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "variable_declarator"  :subid("72_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1162
 .annotate 'line', 417
-    .const 'Sub' $P1202 = "73_1278500542.82783" 
+    .const 'Sub' $P1202 = "73_1279529234.12714" 
     capture_lex $P1202
     new $P1161, 'ExceptionHandler'
     set_addr $P1161, control_1160
@@ -21549,7 +22227,7 @@
     iseq $I1187, $S1186, "has"
     if $I1187, if_1184
 .annotate 'line', 434
-    .const 'Sub' $P1202 = "73_1278500542.82783" 
+    .const 'Sub' $P1202 = "73_1279529234.12714" 
     capture_lex $P1202
     $P1202()
     goto if_1184_end
@@ -21609,7 +22287,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1201"  :anon :subid("73_1278500542.82783") :outer("72_1278500542.82783")
+.sub "_block1201"  :anon :subid("73_1279529234.12714") :outer("72_1279529234.12714")
 .annotate 'line', 435
     new $P1203, "Undef"
     .lex "$scope", $P1203
@@ -21671,7 +22349,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "routine_declarator:sym<sub>"  :subid("74_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "routine_declarator:sym<sub>"  :subid("74_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1233
 .annotate 'line', 445
     new $P1232, 'ExceptionHandler'
@@ -21702,7 +22380,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "routine_declarator:sym<method>"  :subid("75_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "routine_declarator:sym<method>"  :subid("75_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1243
 .annotate 'line', 446
     new $P1242, 'ExceptionHandler'
@@ -21733,10 +22411,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "routine_def"  :subid("76_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "routine_def"  :subid("76_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1253
 .annotate 'line', 448
-    .const 'Sub' $P1264 = "77_1278500542.82783" 
+    .const 'Sub' $P1264 = "77_1279529234.12714" 
     capture_lex $P1264
     new $P1252, 'ExceptionHandler'
     set_addr $P1252, control_1251
@@ -21773,7 +22451,7 @@
     new $P1262, "Undef"
   vivify_423:
     unless $P1262, if_1260_end
-    .const 'Sub' $P1264 = "77_1278500542.82783" 
+    .const 'Sub' $P1264 = "77_1279529234.12714" 
     capture_lex $P1264
     $P1264()
   if_1260_end:
@@ -21792,7 +22470,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1263"  :anon :subid("77_1278500542.82783") :outer("76_1278500542.82783")
+.sub "_block1263"  :anon :subid("77_1279529234.12714") :outer("76_1279529234.12714")
 .annotate 'line', 453
     new $P1265, "Undef"
     .lex "$name", $P1265
@@ -21889,10 +22567,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "method_def"  :subid("78_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "method_def"  :subid("78_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1303
 .annotate 'line', 466
-    .const 'Sub' $P1319 = "79_1278500542.82783" 
+    .const 'Sub' $P1319 = "79_1279529234.12714" 
     capture_lex $P1319
     new $P1302, 'ExceptionHandler'
     set_addr $P1302, control_1301
@@ -21944,7 +22622,7 @@
     new $P1317, "Undef"
   vivify_442:
     unless $P1317, if_1315_end
-    .const 'Sub' $P1319 = "79_1278500542.82783" 
+    .const 'Sub' $P1319 = "79_1279529234.12714" 
     capture_lex $P1319
     $P1319()
   if_1315_end:
@@ -21978,7 +22656,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1318"  :anon :subid("79_1278500542.82783") :outer("78_1278500542.82783")
+.sub "_block1318"  :anon :subid("79_1279529234.12714") :outer("78_1279529234.12714")
 .annotate 'line', 473
     new $P1320, "Undef"
     .lex "$name", $P1320
@@ -22010,12 +22688,12 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "signature"  :subid("80_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "signature"  :subid("80_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1343
 .annotate 'line', 481
-    .const 'Sub' $P1369 = "82_1278500542.82783" 
+    .const 'Sub' $P1369 = "82_1279529234.12714" 
     capture_lex $P1369
-    .const 'Sub' $P1354 = "81_1278500542.82783" 
+    .const 'Sub' $P1354 = "81_1279529234.12714" 
     capture_lex $P1354
     new $P1342, 'ExceptionHandler'
     set_addr $P1342, control_1341
@@ -22059,7 +22737,7 @@
     unless $P1348, loop1360_done
     shift $P1352, $P1348
   loop1360_redo:
-    .const 'Sub' $P1354 = "81_1278500542.82783" 
+    .const 'Sub' $P1354 = "81_1279529234.12714" 
     capture_lex $P1354
     $P1354($P1352)
   loop1360_next:
@@ -22088,7 +22766,7 @@
     set $P1363, $I1367
     goto if_1364_end
   if_1364:
-    .const 'Sub' $P1369 = "82_1278500542.82783" 
+    .const 'Sub' $P1369 = "82_1279529234.12714" 
     capture_lex $P1369
     $P1395 = $P1369()
     set $P1363, $P1395
@@ -22104,7 +22782,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1353"  :anon :subid("81_1278500542.82783") :outer("80_1278500542.82783")
+.sub "_block1353"  :anon :subid("81_1279529234.12714") :outer("80_1279529234.12714")
     .param pmc param_1355
 .annotate 'line', 484
     .lex "$_", param_1355
@@ -22118,9 +22796,9 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "_block1368"  :anon :subid("82_1278500542.82783") :outer("80_1278500542.82783")
+.sub "_block1368"  :anon :subid("82_1279529234.12714") :outer("80_1279529234.12714")
 .annotate 'line', 487
-    .const 'Sub' $P1378 = "83_1278500542.82783" 
+    .const 'Sub' $P1378 = "83_1279529234.12714" 
     capture_lex $P1378
 .annotate 'line', 488
     $P1370 = root_new ['parrot';'ResizablePMCArray']
@@ -22141,7 +22819,7 @@
     unless $P1372, loop1388_done
     shift $P1376, $P1372
   loop1388_redo:
-    .const 'Sub' $P1378 = "83_1278500542.82783" 
+    .const 'Sub' $P1378 = "83_1279529234.12714" 
     capture_lex $P1378
     $P1378($P1376)
   loop1388_next:
@@ -22172,7 +22850,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1377"  :anon :subid("83_1278500542.82783") :outer("82_1278500542.82783")
+.sub "_block1377"  :anon :subid("83_1279529234.12714") :outer("82_1279529234.12714")
     .param pmc param_1379
 .annotate 'line', 489
     .lex "$_", param_1379
@@ -22195,10 +22873,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "parameter"  :subid("84_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "parameter"  :subid("84_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1400
 .annotate 'line', 496
-    .const 'Sub' $P1481 = "85_1278500542.82783" 
+    .const 'Sub' $P1481 = "85_1279529234.12714" 
     capture_lex $P1481
     new $P1399, 'ExceptionHandler'
     set_addr $P1399, control_1398
@@ -22424,7 +23102,7 @@
     new $P1479, "Undef"
   vivify_488:
     unless $P1479, if_1477_end
-    .const 'Sub' $P1481 = "85_1278500542.82783" 
+    .const 'Sub' $P1481 = "85_1279529234.12714" 
     capture_lex $P1481
     $P1481()
   if_1477_end:
@@ -22444,9 +23122,9 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "_block1480"  :anon :subid("85_1278500542.82783") :outer("84_1278500542.82783")
+.sub "_block1480"  :anon :subid("85_1279529234.12714") :outer("84_1279529234.12714")
 .annotate 'line', 527
-    .const 'Sub' $P1493 = "86_1278500542.82783" 
+    .const 'Sub' $P1493 = "86_1279529234.12714" 
     capture_lex $P1493
 .annotate 'line', 528
     $P1482 = root_new ['parrot';'ResizablePMCArray']
@@ -22485,7 +23163,7 @@
     unless $P1484, loop1499_done
     shift $P1491, $P1484
   loop1499_redo:
-    .const 'Sub' $P1493 = "86_1278500542.82783" 
+    .const 'Sub' $P1493 = "86_1279529234.12714" 
     capture_lex $P1493
     $P1493($P1491)
   loop1499_next:
@@ -22509,7 +23187,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1492"  :anon :subid("86_1278500542.82783") :outer("85_1278500542.82783")
+.sub "_block1492"  :anon :subid("86_1279529234.12714") :outer("85_1279529234.12714")
     .param pmc param_1494
 .annotate 'line', 529
     .lex "$_", param_1494
@@ -22523,7 +23201,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "param_var"  :subid("87_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "param_var"  :subid("87_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1512
 .annotate 'line', 536
     new $P1511, 'ExceptionHandler'
@@ -22577,7 +23255,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "named_param"  :subid("88_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "named_param"  :subid("88_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1532
 .annotate 'line', 544
     new $P1531, 'ExceptionHandler'
@@ -22631,14 +23309,14 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "regex_declarator"  :subid("89_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "regex_declarator"  :subid("89_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1549
     .param pmc param_1550 :optional
     .param int has_param_1550 :opt_flag
 .annotate 'line', 550
-    .const 'Sub' $P1620 = "91_1278500542.82783" 
+    .const 'Sub' $P1620 = "91_1279529234.12714" 
     capture_lex $P1620
-    .const 'Sub' $P1592 = "90_1278500542.82783" 
+    .const 'Sub' $P1592 = "90_1279529234.12714" 
     capture_lex $P1592
     new $P1548, 'ExceptionHandler'
     set_addr $P1548, control_1547
@@ -22696,13 +23374,13 @@
     iseq $I1590, $S1589, "open"
     if $I1590, if_1587
 .annotate 'line', 596
-    .const 'Sub' $P1620 = "91_1278500542.82783" 
+    .const 'Sub' $P1620 = "91_1279529234.12714" 
     capture_lex $P1620
     $P1620()
     goto if_1587_end
   if_1587:
 .annotate 'line', 583
-    .const 'Sub' $P1592 = "90_1278500542.82783" 
+    .const 'Sub' $P1592 = "90_1279529234.12714" 
     capture_lex $P1592
     $P1592()
   if_1587_end:
@@ -22759,7 +23437,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1619"  :anon :subid("91_1278500542.82783") :outer("89_1278500542.82783")
+.sub "_block1619"  :anon :subid("91_1279529234.12714") :outer("89_1279529234.12714")
 .annotate 'line', 597
     new $P1621, "Undef"
     .lex "$regex", $P1621
@@ -22811,7 +23489,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "_block1591"  :anon :subid("90_1278500542.82783") :outer("89_1278500542.82783")
+.sub "_block1591"  :anon :subid("90_1279529234.12714") :outer("89_1279529234.12714")
 .annotate 'line', 584
     $P1593 = root_new ['parrot';'Hash']
     .lex "%h", $P1593
@@ -22910,7 +23588,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "dotty"  :subid("92_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "dotty"  :subid("92_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1648
 .annotate 'line', 614
     new $P1647, 'ExceptionHandler'
@@ -23008,7 +23686,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<self>"  :subid("93_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<self>"  :subid("93_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1680
 .annotate 'line', 623
     new $P1679, 'ExceptionHandler'
@@ -23034,7 +23712,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<identifier>"  :subid("94_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<identifier>"  :subid("94_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1689
 .annotate 'line', 627
     new $P1688, 'ExceptionHandler'
@@ -23084,7 +23762,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<name>"  :subid("95_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<name>"  :subid("95_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1705
 .annotate 'line', 633
     new $P1704, 'ExceptionHandler'
@@ -23203,7 +23881,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<pir::op>"  :subid("96_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<pir::op>"  :subid("96_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1747
 .annotate 'line', 647
     new $P1746, 'ExceptionHandler'
@@ -23295,7 +23973,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "args"  :subid("97_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "args"  :subid("97_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1776
 .annotate 'line', 662
     new $P1775, 'ExceptionHandler'
@@ -23326,10 +24004,10 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "arglist"  :subid("98_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "arglist"  :subid("98_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1786
 .annotate 'line', 664
-    .const 'Sub' $P1797 = "99_1278500542.82783" 
+    .const 'Sub' $P1797 = "99_1279529234.12714" 
     capture_lex $P1797
     new $P1785, 'ExceptionHandler'
     set_addr $P1785, control_1784
@@ -23361,7 +24039,7 @@
     new $P1795, "Undef"
   vivify_556:
     unless $P1795, if_1793_end
-    .const 'Sub' $P1797 = "99_1278500542.82783" 
+    .const 'Sub' $P1797 = "99_1279529234.12714" 
     capture_lex $P1797
     $P1797()
   if_1793_end:
@@ -23518,9 +24196,9 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "_block1796"  :anon :subid("99_1278500542.82783") :outer("98_1278500542.82783")
+.sub "_block1796"  :anon :subid("99_1279529234.12714") :outer("98_1279529234.12714")
 .annotate 'line', 666
-    .const 'Sub' $P1818 = "100_1278500542.82783" 
+    .const 'Sub' $P1818 = "100_1279529234.12714" 
     capture_lex $P1818
 .annotate 'line', 667
     new $P1798, "Undef"
@@ -23573,7 +24251,7 @@
     unless $P1812, loop1823_done
     shift $P1816, $P1812
   loop1823_redo:
-    .const 'Sub' $P1818 = "100_1278500542.82783" 
+    .const 'Sub' $P1818 = "100_1279529234.12714" 
     capture_lex $P1818
     $P1818($P1816)
   loop1823_next:
@@ -23596,7 +24274,7 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block1817"  :anon :subid("100_1278500542.82783") :outer("99_1278500542.82783")
+.sub "_block1817"  :anon :subid("100_1279529234.12714") :outer("99_1279529234.12714")
     .param pmc param_1819
 .annotate 'line', 669
     .lex "$_", param_1819
@@ -23609,7 +24287,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<value>"  :subid("101_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<value>"  :subid("101_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1890
 .annotate 'line', 690
     new $P1889, 'ExceptionHandler'
@@ -23640,7 +24318,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "circumfix:sym<( )>"  :subid("102_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "circumfix:sym<( )>"  :subid("102_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1900
 .annotate 'line', 692
     new $P1899, 'ExceptionHandler'
@@ -23697,7 +24375,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "circumfix:sym<[ ]>"  :subid("103_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "circumfix:sym<[ ]>"  :subid("103_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1918
 .annotate 'line', 698
     new $P1917, 'ExceptionHandler'
@@ -23774,7 +24452,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "circumfix:sym<ang>"  :subid("104_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "circumfix:sym<ang>"  :subid("104_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1945
 .annotate 'line', 713
     new $P1944, 'ExceptionHandler'
@@ -23805,7 +24483,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub unicode:"circumfix:sym<\x{ab} \x{bb}>"  :subid("105_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub unicode:"circumfix:sym<\x{ab} \x{bb}>"  :subid("105_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1955
 .annotate 'line', 714
     new $P1954, 'ExceptionHandler'
@@ -23836,7 +24514,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "circumfix:sym<{ }>"  :subid("106_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "circumfix:sym<{ }>"  :subid("106_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1965
 .annotate 'line', 716
     new $P1964, 'ExceptionHandler'
@@ -23915,7 +24593,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "circumfix:sym<sigil>"  :subid("107_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "circumfix:sym<sigil>"  :subid("107_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_1989
 .annotate 'line', 724
     new $P1988, 'ExceptionHandler'
@@ -23995,7 +24673,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "semilist"  :subid("108_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "semilist"  :subid("108_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2018
 .annotate 'line', 731
     new $P2017, 'ExceptionHandler'
@@ -24026,7 +24704,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postcircumfix:sym<[ ]>"  :subid("109_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postcircumfix:sym<[ ]>"  :subid("109_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2028
 .annotate 'line', 733
     new $P2027, 'ExceptionHandler'
@@ -24064,7 +24742,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postcircumfix:sym<{ }>"  :subid("110_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postcircumfix:sym<{ }>"  :subid("110_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2041
 .annotate 'line', 739
     new $P2040, 'ExceptionHandler'
@@ -24102,7 +24780,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postcircumfix:sym<ang>"  :subid("111_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postcircumfix:sym<ang>"  :subid("111_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2054
 .annotate 'line', 745
     new $P2053, 'ExceptionHandler'
@@ -24140,7 +24818,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postcircumfix:sym<( )>"  :subid("112_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postcircumfix:sym<( )>"  :subid("112_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2067
 .annotate 'line', 751
     new $P2066, 'ExceptionHandler'
@@ -24173,7 +24851,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "value"  :subid("113_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "value"  :subid("113_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2077
 .annotate 'line', 755
     new $P2076, 'ExceptionHandler'
@@ -24229,7 +24907,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "number"  :subid("114_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "number"  :subid("114_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2094
 .annotate 'line', 759
     new $P2093, 'ExceptionHandler'
@@ -24308,7 +24986,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym<apos>"  :subid("115_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym<apos>"  :subid("115_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2122
 .annotate 'line', 765
     new $P2121, 'ExceptionHandler'
@@ -24339,7 +25017,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym<dblq>"  :subid("116_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym<dblq>"  :subid("116_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2132
 .annotate 'line', 766
     new $P2131, 'ExceptionHandler'
@@ -24370,7 +25048,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym<qq>"  :subid("117_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym<qq>"  :subid("117_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2142
 .annotate 'line', 767
     new $P2141, 'ExceptionHandler'
@@ -24401,7 +25079,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym<q>"  :subid("118_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym<q>"  :subid("118_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2152
 .annotate 'line', 768
     new $P2151, 'ExceptionHandler'
@@ -24432,7 +25110,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym<Q>"  :subid("119_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym<Q>"  :subid("119_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2162
 .annotate 'line', 769
     new $P2161, 'ExceptionHandler'
@@ -24463,7 +25141,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym<Q:PIR>"  :subid("120_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym<Q:PIR>"  :subid("120_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2172
 .annotate 'line', 770
     new $P2171, 'ExceptionHandler'
@@ -24500,7 +25178,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote:sym</ />"  :subid("121_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote:sym</ />"  :subid("121_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2186
     .param pmc param_2187 :optional
     .param int has_param_2187 :opt_flag
@@ -24610,7 +25288,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<$>"  :subid("122_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote_escape:sym<$>"  :subid("122_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2223
 .annotate 'line', 799
     new $P2222, 'ExceptionHandler'
@@ -24641,7 +25319,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<{ }>"  :subid("123_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote_escape:sym<{ }>"  :subid("123_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2233
 .annotate 'line', 800
     new $P2232, 'ExceptionHandler'
@@ -24680,7 +25358,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "quote_escape:sym<esc>"  :subid("124_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "quote_escape:sym<esc>"  :subid("124_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2247
 .annotate 'line', 805
     new $P2246, 'ExceptionHandler'
@@ -24702,7 +25380,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postfix:sym<.>"  :subid("125_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postfix:sym<.>"  :subid("125_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2254
 .annotate 'line', 809
     new $P2253, 'ExceptionHandler'
@@ -24733,7 +25411,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postfix:sym<++>"  :subid("126_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postfix:sym<++>"  :subid("126_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2264
 .annotate 'line', 811
     new $P2263, 'ExceptionHandler'
@@ -24764,7 +25442,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "postfix:sym<-->"  :subid("127_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "postfix:sym<-->"  :subid("127_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2274
 .annotate 'line', 817
     new $P2273, 'ExceptionHandler'
@@ -24795,7 +25473,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "prefix:sym<make>"  :subid("128_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "prefix:sym<make>"  :subid("128_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2284
 .annotate 'line', 823
     new $P2283, 'ExceptionHandler'
@@ -24826,7 +25504,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<next>"  :subid("129_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<next>"  :subid("129_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2297
 .annotate 'line', 841
     new $P2296, 'ExceptionHandler'
@@ -24848,7 +25526,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<last>"  :subid("130_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<last>"  :subid("130_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2304
 .annotate 'line', 842
     new $P2303, 'ExceptionHandler'
@@ -24870,7 +25548,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "term:sym<redo>"  :subid("131_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "term:sym<redo>"  :subid("131_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2311
 .annotate 'line', 843
     new $P2310, 'ExceptionHandler'
@@ -24892,7 +25570,7 @@
 
 .namespace ["NQP";"Actions"]
 .include "except_types.pasm"
-.sub "infix:sym<~~>"  :subid("132_1278500542.82783") :method :outer("11_1278500542.82783")
+.sub "infix:sym<~~>"  :subid("132_1279529234.12714") :method :outer("11_1279529234.12714")
     .param pmc param_2318
 .annotate 'line', 845
     new $P2317, 'ExceptionHandler'
@@ -24918,24 +25596,24 @@
 
 
 .namespace ["NQP";"RegexActions"]
-.sub "_block2325"  :subid("133_1278500542.82783") :outer("11_1278500542.82783")
+.sub "_block2325"  :subid("133_1279529234.12714") :outer("11_1279529234.12714")
 .annotate 'line', 850
-    .const 'Sub' $P2411 = "140_1278500542.82783" 
+    .const 'Sub' $P2411 = "140_1279529234.12714" 
     capture_lex $P2411
-    .const 'Sub' $P2398 = "139_1278500542.82783" 
+    .const 'Sub' $P2398 = "139_1279529234.12714" 
     capture_lex $P2398
-    .const 'Sub' $P2381 = "138_1278500542.82783" 
+    .const 'Sub' $P2381 = "138_1279529234.12714" 
     capture_lex $P2381
-    .const 'Sub' $P2368 = "137_1278500542.82783" 
+    .const 'Sub' $P2368 = "137_1279529234.12714" 
     capture_lex $P2368
-    .const 'Sub' $P2355 = "136_1278500542.82783" 
+    .const 'Sub' $P2355 = "136_1279529234.12714" 
     capture_lex $P2355
-    .const 'Sub' $P2342 = "135_1278500542.82783" 
+    .const 'Sub' $P2342 = "135_1279529234.12714" 
     capture_lex $P2342
-    .const 'Sub' $P2327 = "134_1278500542.82783" 
+    .const 'Sub' $P2327 = "134_1279529234.12714" 
     capture_lex $P2327
 .annotate 'line', 884
-    .const 'Sub' $P2411 = "140_1278500542.82783" 
+    .const 'Sub' $P2411 = "140_1279529234.12714" 
     newclosure $P2436, $P2411
 .annotate 'line', 850
     .return ($P2436)
@@ -24944,7 +25622,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "metachar:sym<:my>"  :subid("134_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "metachar:sym<:my>"  :subid("134_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2330
 .annotate 'line', 852
     new $P2329, 'ExceptionHandler'
@@ -24985,7 +25663,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "metachar:sym<{ }>"  :subid("135_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "metachar:sym<{ }>"  :subid("135_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2345
 .annotate 'line', 858
     new $P2344, 'ExceptionHandler'
@@ -25021,7 +25699,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "metachar:sym<nqpvar>"  :subid("136_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "metachar:sym<nqpvar>"  :subid("136_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2358
 .annotate 'line', 863
     new $P2357, 'ExceptionHandler'
@@ -25057,7 +25735,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "assertion:sym<{ }>"  :subid("137_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "assertion:sym<{ }>"  :subid("137_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2371
 .annotate 'line', 868
     new $P2370, 'ExceptionHandler'
@@ -25093,7 +25771,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "assertion:sym<?{ }>"  :subid("138_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "assertion:sym<?{ }>"  :subid("138_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2384
 .annotate 'line', 873
     new $P2383, 'ExceptionHandler'
@@ -25141,7 +25819,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "assertion:sym<var>"  :subid("139_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "assertion:sym<var>"  :subid("139_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2401
 .annotate 'line', 879
     new $P2400, 'ExceptionHandler'
@@ -25177,7 +25855,7 @@
 
 .namespace ["NQP";"RegexActions"]
 .include "except_types.pasm"
-.sub "codeblock"  :subid("140_1278500542.82783") :method :outer("133_1278500542.82783")
+.sub "codeblock"  :subid("140_1279529234.12714") :method :outer("133_1279529234.12714")
     .param pmc param_2414
 .annotate 'line', 884
     new $P2413, 'ExceptionHandler'
@@ -25241,18 +25919,18 @@
 
 
 .namespace ["NQP";"Actions"]
-.sub "_block2438" :load :anon :subid("141_1278500542.82783")
+.sub "_block2438" :load :anon :subid("141_1279529234.12714")
 .annotate 'line', 3
-    .const 'Sub' $P2440 = "11_1278500542.82783" 
+    .const 'Sub' $P2440 = "11_1279529234.12714" 
     $P2441 = $P2440()
     .return ($P2441)
 .end
 
 
 .namespace []
-.sub "_block2448" :load :anon :subid("143_1278500542.82783")
+.sub "_block2448" :load :anon :subid("143_1279529234.12714")
 .annotate 'line', 1
-    .const 'Sub' $P2450 = "10_1278500542.82783" 
+    .const 'Sub' $P2450 = "10_1279529234.12714" 
     $P2451 = $P2450()
     .return ($P2451)
 .end

Modified: trunk/ext/nqp-rx/src/stage0/P6Regex-s0.pir
==============================================================================
--- trunk/ext/nqp-rx/src/stage0/P6Regex-s0.pir	Mon Jul 19 07:59:55 2010	(r48109)
+++ trunk/ext/nqp-rx/src/stage0/P6Regex-s0.pir	Mon Jul 19 09:38:32 2010	(r48110)
@@ -16,7 +16,7 @@
 ### .include 'gen/p6regex-grammar.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500530.77787")
+.sub "_block11"  :anon :subid("10_1279529218.55263")
 .annotate 'line', 0
     get_hll_global $P14, ["Regex";"P6Regex";"Grammar"], "_block13" 
     capture_lex $P14
@@ -30,153 +30,153 @@
 .annotate 'line', 3
     get_hll_global $P14, ["Regex";"P6Regex";"Grammar"], "_block13" 
     capture_lex $P14
-    $P596 = $P14()
+    $P573 = $P14()
 .annotate 'line', 1
-    .return ($P596)
-    .const 'Sub' $P598 = "161_1278500530.77787" 
-    .return ($P598)
+    .return ($P573)
+    .const 'Sub' $P575 = "161_1279529218.55263" 
+    .return ($P575)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post162") :outer("10_1278500530.77787")
+.sub "" :load :init :subid("post162") :outer("10_1279529218.55263")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500530.77787" 
+    .const 'Sub' $P12 = "10_1279529218.55263" 
     .local pmc block
     set block, $P12
-    $P601 = get_root_global ["parrot"], "P6metaclass"
-    $P601."new_class"("Regex::P6Regex::Grammar", "HLL::Grammar" :named("parent"))
+    $P578 = get_root_global ["parrot"], "P6metaclass"
+    $P578."new_class"("Regex::P6Regex::Grammar", "HLL::Grammar" :named("parent"))
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block13"  :subid("11_1278500530.77787") :outer("10_1278500530.77787")
+.sub "_block13"  :subid("11_1279529218.55263") :outer("10_1279529218.55263")
 .annotate 'line', 3
-    .const 'Sub' $P584 = "158_1278500530.77787" 
-    capture_lex $P584
-    .const 'Sub' $P576 = "156_1278500530.77787" 
-    capture_lex $P576
-    .const 'Sub' $P568 = "154_1278500530.77787" 
-    capture_lex $P568
-    .const 'Sub' $P547 = "149_1278500530.77787" 
-    capture_lex $P547
-    .const 'Sub' $P512 = "143_1278500530.77787" 
-    capture_lex $P512
-    .const 'Sub' $P500 = "140_1278500530.77787" 
-    capture_lex $P500
-    .const 'Sub' $P487 = "137_1278500530.77787" 
-    capture_lex $P487
-    .const 'Sub' $P481 = "135_1278500530.77787" 
-    capture_lex $P481
-    .const 'Sub' $P470 = "132_1278500530.77787" 
+    .const 'Sub' $P562 = "158_1279529218.55263" 
+    capture_lex $P562
+    .const 'Sub' $P555 = "156_1279529218.55263" 
+    capture_lex $P555
+    .const 'Sub' $P548 = "154_1279529218.55263" 
+    capture_lex $P548
+    .const 'Sub' $P528 = "149_1279529218.55263" 
+    capture_lex $P528
+    .const 'Sub' $P494 = "143_1279529218.55263" 
+    capture_lex $P494
+    .const 'Sub' $P482 = "140_1279529218.55263" 
+    capture_lex $P482
+    .const 'Sub' $P470 = "137_1279529218.55263" 
     capture_lex $P470
-    .const 'Sub' $P459 = "129_1278500530.77787" 
-    capture_lex $P459
-    .const 'Sub' $P450 = "125_1278500530.77787" 
-    capture_lex $P450
-    .const 'Sub' $P444 = "123_1278500530.77787" 
-    capture_lex $P444
-    .const 'Sub' $P438 = "121_1278500530.77787" 
-    capture_lex $P438
-    .const 'Sub' $P432 = "119_1278500530.77787" 
-    capture_lex $P432
-    .const 'Sub' $P426 = "117_1278500530.77787" 
-    capture_lex $P426
-    .const 'Sub' $P418 = "115_1278500530.77787" 
-    capture_lex $P418
-    .const 'Sub' $P407 = "113_1278500530.77787" 
-    capture_lex $P407
-    .const 'Sub' $P396 = "111_1278500530.77787" 
-    capture_lex $P396
-    .const 'Sub' $P390 = "109_1278500530.77787" 
+    .const 'Sub' $P464 = "135_1279529218.55263" 
+    capture_lex $P464
+    .const 'Sub' $P453 = "132_1279529218.55263" 
+    capture_lex $P453
+    .const 'Sub' $P442 = "129_1279529218.55263" 
+    capture_lex $P442
+    .const 'Sub' $P433 = "125_1279529218.55263" 
+    capture_lex $P433
+    .const 'Sub' $P427 = "123_1279529218.55263" 
+    capture_lex $P427
+    .const 'Sub' $P421 = "121_1279529218.55263" 
+    capture_lex $P421
+    .const 'Sub' $P415 = "119_1279529218.55263" 
+    capture_lex $P415
+    .const 'Sub' $P409 = "117_1279529218.55263" 
+    capture_lex $P409
+    .const 'Sub' $P401 = "115_1279529218.55263" 
+    capture_lex $P401
+    .const 'Sub' $P390 = "113_1279529218.55263" 
     capture_lex $P390
-    .const 'Sub' $P384 = "107_1278500530.77787" 
-    capture_lex $P384
-    .const 'Sub' $P378 = "105_1278500530.77787" 
-    capture_lex $P378
-    .const 'Sub' $P372 = "103_1278500530.77787" 
-    capture_lex $P372
-    .const 'Sub' $P366 = "101_1278500530.77787" 
-    capture_lex $P366
-    .const 'Sub' $P360 = "99_1278500530.77787" 
-    capture_lex $P360
-    .const 'Sub' $P354 = "97_1278500530.77787" 
-    capture_lex $P354
-    .const 'Sub' $P348 = "95_1278500530.77787" 
-    capture_lex $P348
-    .const 'Sub' $P336 = "91_1278500530.77787" 
-    capture_lex $P336
-    .const 'Sub' $P324 = "89_1278500530.77787" 
-    capture_lex $P324
-    .const 'Sub' $P317 = "87_1278500530.77787" 
-    capture_lex $P317
-    .const 'Sub' $P300 = "85_1278500530.77787" 
-    capture_lex $P300
-    .const 'Sub' $P293 = "83_1278500530.77787" 
-    capture_lex $P293
-    .const 'Sub' $P287 = "81_1278500530.77787" 
-    capture_lex $P287
-    .const 'Sub' $P281 = "79_1278500530.77787" 
-    capture_lex $P281
-    .const 'Sub' $P274 = "77_1278500530.77787" 
-    capture_lex $P274
-    .const 'Sub' $P267 = "75_1278500530.77787" 
-    capture_lex $P267
-    .const 'Sub' $P260 = "73_1278500530.77787" 
-    capture_lex $P260
-    .const 'Sub' $P253 = "71_1278500530.77787" 
-    capture_lex $P253
-    .const 'Sub' $P247 = "69_1278500530.77787" 
-    capture_lex $P247
-    .const 'Sub' $P241 = "67_1278500530.77787" 
-    capture_lex $P241
-    .const 'Sub' $P235 = "65_1278500530.77787" 
-    capture_lex $P235
-    .const 'Sub' $P229 = "63_1278500530.77787" 
-    capture_lex $P229
-    .const 'Sub' $P223 = "61_1278500530.77787" 
-    capture_lex $P223
-    .const 'Sub' $P218 = "59_1278500530.77787" 
-    capture_lex $P218
-    .const 'Sub' $P213 = "57_1278500530.77787" 
+    .const 'Sub' $P379 = "111_1279529218.55263" 
+    capture_lex $P379
+    .const 'Sub' $P373 = "109_1279529218.55263" 
+    capture_lex $P373
+    .const 'Sub' $P367 = "107_1279529218.55263" 
+    capture_lex $P367
+    .const 'Sub' $P361 = "105_1279529218.55263" 
+    capture_lex $P361
+    .const 'Sub' $P355 = "103_1279529218.55263" 
+    capture_lex $P355
+    .const 'Sub' $P349 = "101_1279529218.55263" 
+    capture_lex $P349
+    .const 'Sub' $P343 = "99_1279529218.55263" 
+    capture_lex $P343
+    .const 'Sub' $P337 = "97_1279529218.55263" 
+    capture_lex $P337
+    .const 'Sub' $P331 = "95_1279529218.55263" 
+    capture_lex $P331
+    .const 'Sub' $P319 = "91_1279529218.55263" 
+    capture_lex $P319
+    .const 'Sub' $P309 = "89_1279529218.55263" 
+    capture_lex $P309
+    .const 'Sub' $P302 = "87_1279529218.55263" 
+    capture_lex $P302
+    .const 'Sub' $P290 = "85_1279529218.55263" 
+    capture_lex $P290
+    .const 'Sub' $P283 = "83_1279529218.55263" 
+    capture_lex $P283
+    .const 'Sub' $P277 = "81_1279529218.55263" 
+    capture_lex $P277
+    .const 'Sub' $P271 = "79_1279529218.55263" 
+    capture_lex $P271
+    .const 'Sub' $P264 = "77_1279529218.55263" 
+    capture_lex $P264
+    .const 'Sub' $P257 = "75_1279529218.55263" 
+    capture_lex $P257
+    .const 'Sub' $P250 = "73_1279529218.55263" 
+    capture_lex $P250
+    .const 'Sub' $P243 = "71_1279529218.55263" 
+    capture_lex $P243
+    .const 'Sub' $P237 = "69_1279529218.55263" 
+    capture_lex $P237
+    .const 'Sub' $P231 = "67_1279529218.55263" 
+    capture_lex $P231
+    .const 'Sub' $P225 = "65_1279529218.55263" 
+    capture_lex $P225
+    .const 'Sub' $P219 = "63_1279529218.55263" 
+    capture_lex $P219
+    .const 'Sub' $P213 = "61_1279529218.55263" 
     capture_lex $P213
-    .const 'Sub' $P207 = "55_1278500530.77787" 
-    capture_lex $P207
-    .const 'Sub' $P201 = "53_1278500530.77787" 
-    capture_lex $P201
-    .const 'Sub' $P195 = "51_1278500530.77787" 
-    capture_lex $P195
-    .const 'Sub' $P179 = "46_1278500530.77787" 
-    capture_lex $P179
-    .const 'Sub' $P163 = "44_1278500530.77787" 
-    capture_lex $P163
-    .const 'Sub' $P156 = "42_1278500530.77787" 
-    capture_lex $P156
-    .const 'Sub' $P149 = "40_1278500530.77787" 
-    capture_lex $P149
-    .const 'Sub' $P142 = "38_1278500530.77787" 
-    capture_lex $P142
-    .const 'Sub' $P123 = "33_1278500530.77787" 
-    capture_lex $P123
-    .const 'Sub' $P110 = "30_1278500530.77787" 
-    capture_lex $P110
-    .const 'Sub' $P103 = "28_1278500530.77787" 
-    capture_lex $P103
-    .const 'Sub' $P91 = "26_1278500530.77787" 
-    capture_lex $P91
-    .const 'Sub' $P84 = "24_1278500530.77787" 
-    capture_lex $P84
-    .const 'Sub' $P71 = "22_1278500530.77787" 
-    capture_lex $P71
-    .const 'Sub' $P64 = "20_1278500530.77787" 
-    capture_lex $P64
-    .const 'Sub' $P56 = "18_1278500530.77787" 
-    capture_lex $P56
-    .const 'Sub' $P46 = "15_1278500530.77787" 
-    capture_lex $P46
-    .const 'Sub' $P38 = "13_1278500530.77787" 
+    .const 'Sub' $P208 = "59_1279529218.55263" 
+    capture_lex $P208
+    .const 'Sub' $P203 = "57_1279529218.55263" 
+    capture_lex $P203
+    .const 'Sub' $P197 = "55_1279529218.55263" 
+    capture_lex $P197
+    .const 'Sub' $P191 = "53_1279529218.55263" 
+    capture_lex $P191
+    .const 'Sub' $P185 = "51_1279529218.55263" 
+    capture_lex $P185
+    .const 'Sub' $P170 = "46_1279529218.55263" 
+    capture_lex $P170
+    .const 'Sub' $P155 = "44_1279529218.55263" 
+    capture_lex $P155
+    .const 'Sub' $P148 = "42_1279529218.55263" 
+    capture_lex $P148
+    .const 'Sub' $P141 = "40_1279529218.55263" 
+    capture_lex $P141
+    .const 'Sub' $P134 = "38_1279529218.55263" 
+    capture_lex $P134
+    .const 'Sub' $P117 = "33_1279529218.55263" 
+    capture_lex $P117
+    .const 'Sub' $P105 = "30_1279529218.55263" 
+    capture_lex $P105
+    .const 'Sub' $P98 = "28_1279529218.55263" 
+    capture_lex $P98
+    .const 'Sub' $P88 = "26_1279529218.55263" 
+    capture_lex $P88
+    .const 'Sub' $P81 = "24_1279529218.55263" 
+    capture_lex $P81
+    .const 'Sub' $P69 = "22_1279529218.55263" 
+    capture_lex $P69
+    .const 'Sub' $P62 = "20_1279529218.55263" 
+    capture_lex $P62
+    .const 'Sub' $P55 = "18_1279529218.55263" 
+    capture_lex $P55
+    .const 'Sub' $P45 = "15_1279529218.55263" 
+    capture_lex $P45
+    .const 'Sub' $P38 = "13_1279529218.55263" 
     capture_lex $P38
-    .const 'Sub' $P15 = "12_1278500530.77787" 
+    .const 'Sub' $P15 = "12_1279529218.55263" 
     capture_lex $P15
     $P0 = find_dynamic_lex "$*CTXSAVE"
     if null $P0 goto ctxsave_done
@@ -184,17 +184,17 @@
     unless $I0 goto ctxsave_done
     $P0."ctxsave"()
   ctxsave_done:
-    .const 'Sub' $P584 = "158_1278500530.77787" 
-    capture_lex $P584
-    .return ($P584)
-    .const 'Sub' $P593 = "160_1278500530.77787" 
-    .return ($P593)
+    .const 'Sub' $P562 = "158_1279529218.55263" 
+    capture_lex $P562
+    .return ($P562)
+    .const 'Sub' $P570 = "160_1279529218.55263" 
+    .return ($P570)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
 .include "except_types.pasm"
-.sub "obs"  :subid("12_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "obs"  :subid("12_1279529218.55263") :method :outer("11_1279529218.55263")
     .param pmc param_18
     .param pmc param_19
     .param pmc param_20 :optional
@@ -242,7 +242,7 @@
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "ws"  :subid("13_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "ws"  :subid("13_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
     .local string rx39_tgt
     .local int rx39_pos
@@ -250,8 +250,7 @@
     .local int rx39_eos
     .local int rx39_rep
     .local pmc rx39_cur
-    (rx39_cur, rx39_pos, rx39_tgt) = self."!cursor_start"()
-    rx39_cur."!cursor_debug"("START ", "ws")
+    (rx39_cur, rx39_pos, rx39_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx39_cur
     .local pmc match
     .lex "$/", match
@@ -262,6 +261,8 @@
     sub rx39_off, rx39_pos, 1
     substr rx39_tgt, rx39_tgt, rx39_off
   rx39_start:
+    eq $I10, 1, rx39_restart
+    rx39_cur."!cursor_debug"("START ", "ws")
     $I10 = self.'from'()
     ne $I10, -1, rxscan42_done
     goto rxscan42_scan
@@ -276,8 +277,8 @@
   rxscan42_done:
 .annotate 'line', 8
   # rx rxquantr43 ** 0..*
-    set_addr $I45, rxquantr43_done
-    rx39_cur."!mark_push"(0, rx39_pos, $I45)
+    set_addr $I10, rxquantr43_done
+    rx39_cur."!mark_push"(0, rx39_pos, $I10)
   rxquantr43_loop:
   alt44_0:
     set_addr $I10, alt44_1
@@ -302,16 +303,20 @@
     find_cclass $I11, 4096, rx39_tgt, $I10, rx39_eos
     add rx39_pos, rx39_off, $I11
   alt44_end:
-    (rx39_rep) = rx39_cur."!mark_commit"($I45)
-    rx39_cur."!mark_push"(rx39_rep, rx39_pos, $I45)
+    set_addr $I10, rxquantr43_done
+    (rx39_rep) = rx39_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr43_done
+    rx39_cur."!mark_push"(rx39_rep, rx39_pos, $I10)
     goto rxquantr43_loop
   rxquantr43_done:
   # rx pass
     rx39_cur."!cursor_pass"(rx39_pos, "ws")
     rx39_cur."!cursor_debug"("PASS  ", "ws", " at pos=", rx39_pos)
     .return (rx39_cur)
-  rx39_fail:
+  rx39_restart:
 .annotate 'line', 3
+    rx39_cur."!cursor_debug"("NEXT ", "ws")
+  rx39_fail:
     (rx39_rep, rx39_pos, $I10, $P10) = rx39_cur."!mark_fail"(0)
     lt rx39_pos, -1, rx39_done
     eq rx39_pos, -1, rx39_fail
@@ -325,7 +330,7 @@
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__ws"  :subid("14_1278500530.77787") :method
+.sub "!PREFIX__ws"  :subid("14_1279529218.55263") :method
 .annotate 'line', 3
     new $P41, "ResizablePMCArray"
     push $P41, ""
@@ -334,1108 +339,1232 @@
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "normspace"  :subid("15_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "normspace"  :subid("15_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .const 'Sub' $P52 = "17_1278500530.77787" 
-    capture_lex $P52
-    .local string rx47_tgt
-    .local int rx47_pos
-    .local int rx47_off
-    .local int rx47_eos
-    .local int rx47_rep
-    .local pmc rx47_cur
-    (rx47_cur, rx47_pos, rx47_tgt) = self."!cursor_start"()
-    rx47_cur."!cursor_debug"("START ", "normspace")
-    .lex unicode:"$\x{a2}", rx47_cur
-    .local pmc match
-    .lex "$/", match
-    length rx47_eos, rx47_tgt
-    gt rx47_pos, rx47_eos, rx47_done
-    set rx47_off, 0
-    lt rx47_pos, 2, rx47_start
-    sub rx47_off, rx47_pos, 1
-    substr rx47_tgt, rx47_tgt, rx47_off
-  rx47_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan50_done
-    goto rxscan50_scan
-  rxscan50_loop:
-    ($P10) = rx47_cur."from"()
-    inc $P10
-    set rx47_pos, $P10
-    ge rx47_pos, rx47_eos, rxscan50_done
-  rxscan50_scan:
-    set_addr $I10, rxscan50_loop
-    rx47_cur."!mark_push"(0, rx47_pos, $I10)
-  rxscan50_done:
+    .const 'Sub' $P51 = "17_1279529218.55263" 
+    capture_lex $P51
+    .local string rx46_tgt
+    .local int rx46_pos
+    .local int rx46_off
+    .local int rx46_eos
+    .local int rx46_rep
+    .local pmc rx46_cur
+    (rx46_cur, rx46_pos, rx46_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx46_cur
+    .local pmc match
+    .lex "$/", match
+    length rx46_eos, rx46_tgt
+    gt rx46_pos, rx46_eos, rx46_done
+    set rx46_off, 0
+    lt rx46_pos, 2, rx46_start
+    sub rx46_off, rx46_pos, 1
+    substr rx46_tgt, rx46_tgt, rx46_off
+  rx46_start:
+    eq $I10, 1, rx46_restart
+    rx46_cur."!cursor_debug"("START ", "normspace")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan49_done
+    goto rxscan49_scan
+  rxscan49_loop:
+    ($P10) = rx46_cur."from"()
+    inc $P10
+    set rx46_pos, $P10
+    ge rx46_pos, rx46_eos, rxscan49_done
+  rxscan49_scan:
+    set_addr $I10, rxscan49_loop
+    rx46_cur."!mark_push"(0, rx46_pos, $I10)
+  rxscan49_done:
 .annotate 'line', 10
   # rx subrule "before" subtype=zerowidth negate=
-    rx47_cur."!cursor_pos"(rx47_pos)
-    .const 'Sub' $P52 = "17_1278500530.77787" 
-    capture_lex $P52
-    $P10 = rx47_cur."before"($P52)
-    unless $P10, rx47_fail
+    rx46_cur."!cursor_pos"(rx46_pos)
+    .const 'Sub' $P51 = "17_1279529218.55263" 
+    capture_lex $P51
+    $P10 = rx46_cur."before"($P51)
+    unless $P10, rx46_fail
   # rx subrule "ws" subtype=method negate=
-    rx47_cur."!cursor_pos"(rx47_pos)
-    $P10 = rx47_cur."ws"()
-    unless $P10, rx47_fail
-    rx47_pos = $P10."pos"()
+    rx46_cur."!cursor_pos"(rx46_pos)
+    $P10 = rx46_cur."ws"()
+    unless $P10, rx46_fail
+    rx46_pos = $P10."pos"()
   # rx pass
-    rx47_cur."!cursor_pass"(rx47_pos, "normspace")
-    rx47_cur."!cursor_debug"("PASS  ", "normspace", " at pos=", rx47_pos)
-    .return (rx47_cur)
-  rx47_fail:
+    rx46_cur."!cursor_pass"(rx46_pos, "normspace")
+    rx46_cur."!cursor_debug"("PASS  ", "normspace", " at pos=", rx46_pos)
+    .return (rx46_cur)
+  rx46_restart:
 .annotate 'line', 3
-    (rx47_rep, rx47_pos, $I10, $P10) = rx47_cur."!mark_fail"(0)
-    lt rx47_pos, -1, rx47_done
-    eq rx47_pos, -1, rx47_fail
+    rx46_cur."!cursor_debug"("NEXT ", "normspace")
+  rx46_fail:
+    (rx46_rep, rx46_pos, $I10, $P10) = rx46_cur."!mark_fail"(0)
+    lt rx46_pos, -1, rx46_done
+    eq rx46_pos, -1, rx46_fail
     jump $I10
-  rx47_done:
-    rx47_cur."!cursor_fail"()
-    rx47_cur."!cursor_debug"("FAIL  ", "normspace")
-    .return (rx47_cur)
+  rx46_done:
+    rx46_cur."!cursor_fail"()
+    rx46_cur."!cursor_debug"("FAIL  ", "normspace")
+    .return (rx46_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__normspace"  :subid("16_1278500530.77787") :method
+.sub "!PREFIX__normspace"  :subid("16_1279529218.55263") :method
 .annotate 'line', 3
-    new $P49, "ResizablePMCArray"
-    push $P49, ""
-    .return ($P49)
+    new $P48, "ResizablePMCArray"
+    push $P48, ""
+    .return ($P48)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block51"  :anon :subid("17_1278500530.77787") :method :outer("15_1278500530.77787")
+.sub "_block50"  :anon :subid("17_1279529218.55263") :method :outer("15_1279529218.55263")
 .annotate 'line', 10
-    .local string rx53_tgt
-    .local int rx53_pos
-    .local int rx53_off
-    .local int rx53_eos
-    .local int rx53_rep
-    .local pmc rx53_cur
-    (rx53_cur, rx53_pos, rx53_tgt) = self."!cursor_start"()
-    rx53_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx53_cur
-    .local pmc match
-    .lex "$/", match
-    length rx53_eos, rx53_tgt
-    gt rx53_pos, rx53_eos, rx53_done
-    set rx53_off, 0
-    lt rx53_pos, 2, rx53_start
-    sub rx53_off, rx53_pos, 1
-    substr rx53_tgt, rx53_tgt, rx53_off
-  rx53_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan54_done
-    goto rxscan54_scan
-  rxscan54_loop:
-    ($P10) = rx53_cur."from"()
-    inc $P10
-    set rx53_pos, $P10
-    ge rx53_pos, rx53_eos, rxscan54_done
-  rxscan54_scan:
-    set_addr $I10, rxscan54_loop
-    rx53_cur."!mark_push"(0, rx53_pos, $I10)
-  rxscan54_done:
-  alt55_0:
-    set_addr $I10, alt55_1
-    rx53_cur."!mark_push"(0, rx53_pos, $I10)
+    .local string rx52_tgt
+    .local int rx52_pos
+    .local int rx52_off
+    .local int rx52_eos
+    .local int rx52_rep
+    .local pmc rx52_cur
+    (rx52_cur, rx52_pos, rx52_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx52_cur
+    .local pmc match
+    .lex "$/", match
+    length rx52_eos, rx52_tgt
+    gt rx52_pos, rx52_eos, rx52_done
+    set rx52_off, 0
+    lt rx52_pos, 2, rx52_start
+    sub rx52_off, rx52_pos, 1
+    substr rx52_tgt, rx52_tgt, rx52_off
+  rx52_start:
+    eq $I10, 1, rx52_restart
+    rx52_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan53_done
+    goto rxscan53_scan
+  rxscan53_loop:
+    ($P10) = rx52_cur."from"()
+    inc $P10
+    set rx52_pos, $P10
+    ge rx52_pos, rx52_eos, rxscan53_done
+  rxscan53_scan:
+    set_addr $I10, rxscan53_loop
+    rx52_cur."!mark_push"(0, rx52_pos, $I10)
+  rxscan53_done:
+  alt54_0:
+    set_addr $I10, alt54_1
+    rx52_cur."!mark_push"(0, rx52_pos, $I10)
   # rx charclass s
-    ge rx53_pos, rx53_eos, rx53_fail
-    sub $I10, rx53_pos, rx53_off
-    is_cclass $I11, 32, rx53_tgt, $I10
-    unless $I11, rx53_fail
-    inc rx53_pos
-    goto alt55_end
-  alt55_1:
+    ge rx52_pos, rx52_eos, rx52_fail
+    sub $I10, rx52_pos, rx52_off
+    is_cclass $I11, 32, rx52_tgt, $I10
+    unless $I11, rx52_fail
+    inc rx52_pos
+    goto alt54_end
+  alt54_1:
   # rx literal  "#"
-    add $I11, rx53_pos, 1
-    gt $I11, rx53_eos, rx53_fail
-    sub $I11, rx53_pos, rx53_off
-    substr $S10, rx53_tgt, $I11, 1
-    ne $S10, "#", rx53_fail
-    add rx53_pos, 1
-  alt55_end:
-  # rx pass
-    rx53_cur."!cursor_pass"(rx53_pos, "")
-    rx53_cur."!cursor_debug"("PASS  ", "", " at pos=", rx53_pos)
-    .return (rx53_cur)
-  rx53_fail:
-    (rx53_rep, rx53_pos, $I10, $P10) = rx53_cur."!mark_fail"(0)
-    lt rx53_pos, -1, rx53_done
-    eq rx53_pos, -1, rx53_fail
-    jump $I10
-  rx53_done:
-    rx53_cur."!cursor_fail"()
-    rx53_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx53_cur)
+    add $I11, rx52_pos, 1
+    gt $I11, rx52_eos, rx52_fail
+    sub $I11, rx52_pos, rx52_off
+    substr $S10, rx52_tgt, $I11, 1
+    ne $S10, "#", rx52_fail
+    add rx52_pos, 1
+  alt54_end:
+  # rx pass
+    rx52_cur."!cursor_pass"(rx52_pos, "")
+    rx52_cur."!cursor_debug"("PASS  ", "", " at pos=", rx52_pos)
+    .return (rx52_cur)
+  rx52_restart:
+    rx52_cur."!cursor_debug"("NEXT ", "")
+  rx52_fail:
+    (rx52_rep, rx52_pos, $I10, $P10) = rx52_cur."!mark_fail"(0)
+    lt rx52_pos, -1, rx52_done
+    eq rx52_pos, -1, rx52_fail
+    jump $I10
+  rx52_done:
+    rx52_cur."!cursor_fail"()
+    rx52_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx52_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "identifier"  :subid("18_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx57_tgt
-    .local int rx57_pos
-    .local int rx57_off
-    .local int rx57_eos
-    .local int rx57_rep
-    .local pmc rx57_cur
-    (rx57_cur, rx57_pos, rx57_tgt) = self."!cursor_start"()
-    rx57_cur."!cursor_debug"("START ", "identifier")
-    .lex unicode:"$\x{a2}", rx57_cur
-    .local pmc match
-    .lex "$/", match
-    length rx57_eos, rx57_tgt
-    gt rx57_pos, rx57_eos, rx57_done
-    set rx57_off, 0
-    lt rx57_pos, 2, rx57_start
-    sub rx57_off, rx57_pos, 1
-    substr rx57_tgt, rx57_tgt, rx57_off
-  rx57_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan61_done
-    goto rxscan61_scan
-  rxscan61_loop:
-    ($P10) = rx57_cur."from"()
-    inc $P10
-    set rx57_pos, $P10
-    ge rx57_pos, rx57_eos, rxscan61_done
-  rxscan61_scan:
-    set_addr $I10, rxscan61_loop
-    rx57_cur."!mark_push"(0, rx57_pos, $I10)
-  rxscan61_done:
+.sub "identifier"  :subid("18_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx56_tgt
+    .local int rx56_pos
+    .local int rx56_off
+    .local int rx56_eos
+    .local int rx56_rep
+    .local pmc rx56_cur
+    (rx56_cur, rx56_pos, rx56_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx56_cur
+    .local pmc match
+    .lex "$/", match
+    length rx56_eos, rx56_tgt
+    gt rx56_pos, rx56_eos, rx56_done
+    set rx56_off, 0
+    lt rx56_pos, 2, rx56_start
+    sub rx56_off, rx56_pos, 1
+    substr rx56_tgt, rx56_tgt, rx56_off
+  rx56_start:
+    eq $I10, 1, rx56_restart
+    rx56_cur."!cursor_debug"("START ", "identifier")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan60_done
+    goto rxscan60_scan
+  rxscan60_loop:
+    ($P10) = rx56_cur."from"()
+    inc $P10
+    set rx56_pos, $P10
+    ge rx56_pos, rx56_eos, rxscan60_done
+  rxscan60_scan:
+    set_addr $I10, rxscan60_loop
+    rx56_cur."!mark_push"(0, rx56_pos, $I10)
+  rxscan60_done:
 .annotate 'line', 12
   # rx subrule "ident" subtype=method negate=
-    rx57_cur."!cursor_pos"(rx57_pos)
-    $P10 = rx57_cur."ident"()
-    unless $P10, rx57_fail
-    rx57_pos = $P10."pos"()
-  # rx rxquantr62 ** 0..*
-    set_addr $I63, rxquantr62_done
-    rx57_cur."!mark_push"(0, rx57_pos, $I63)
-  rxquantr62_loop:
+    rx56_cur."!cursor_pos"(rx56_pos)
+    $P10 = rx56_cur."ident"()
+    unless $P10, rx56_fail
+    rx56_pos = $P10."pos"()
+  # rx rxquantr61 ** 0..*
+    set_addr $I10, rxquantr61_done
+    rx56_cur."!mark_push"(0, rx56_pos, $I10)
+  rxquantr61_loop:
   # rx enumcharlist negate=0 
-    ge rx57_pos, rx57_eos, rx57_fail
-    sub $I10, rx57_pos, rx57_off
-    substr $S10, rx57_tgt, $I10, 1
+    ge rx56_pos, rx56_eos, rx56_fail
+    sub $I10, rx56_pos, rx56_off
+    substr $S10, rx56_tgt, $I10, 1
     index $I11, "-'", $S10
-    lt $I11, 0, rx57_fail
-    inc rx57_pos
+    lt $I11, 0, rx56_fail
+    inc rx56_pos
   # rx subrule "ident" subtype=method negate=
-    rx57_cur."!cursor_pos"(rx57_pos)
-    $P10 = rx57_cur."ident"()
-    unless $P10, rx57_fail
-    rx57_pos = $P10."pos"()
-    (rx57_rep) = rx57_cur."!mark_commit"($I63)
-    rx57_cur."!mark_push"(rx57_rep, rx57_pos, $I63)
-    goto rxquantr62_loop
-  rxquantr62_done:
-  # rx pass
-    rx57_cur."!cursor_pass"(rx57_pos, "identifier")
-    rx57_cur."!cursor_debug"("PASS  ", "identifier", " at pos=", rx57_pos)
-    .return (rx57_cur)
-  rx57_fail:
-.annotate 'line', 3
-    (rx57_rep, rx57_pos, $I10, $P10) = rx57_cur."!mark_fail"(0)
-    lt rx57_pos, -1, rx57_done
-    eq rx57_pos, -1, rx57_fail
-    jump $I10
-  rx57_done:
-    rx57_cur."!cursor_fail"()
-    rx57_cur."!cursor_debug"("FAIL  ", "identifier")
-    .return (rx57_cur)
+    rx56_cur."!cursor_pos"(rx56_pos)
+    $P10 = rx56_cur."ident"()
+    unless $P10, rx56_fail
+    rx56_pos = $P10."pos"()
+    set_addr $I10, rxquantr61_done
+    (rx56_rep) = rx56_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr61_done
+    rx56_cur."!mark_push"(rx56_rep, rx56_pos, $I10)
+    goto rxquantr61_loop
+  rxquantr61_done:
+  # rx pass
+    rx56_cur."!cursor_pass"(rx56_pos, "identifier")
+    rx56_cur."!cursor_debug"("PASS  ", "identifier", " at pos=", rx56_pos)
+    .return (rx56_cur)
+  rx56_restart:
+.annotate 'line', 3
+    rx56_cur."!cursor_debug"("NEXT ", "identifier")
+  rx56_fail:
+    (rx56_rep, rx56_pos, $I10, $P10) = rx56_cur."!mark_fail"(0)
+    lt rx56_pos, -1, rx56_done
+    eq rx56_pos, -1, rx56_fail
+    jump $I10
+  rx56_done:
+    rx56_cur."!cursor_fail"()
+    rx56_cur."!cursor_debug"("FAIL  ", "identifier")
+    .return (rx56_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__identifier"  :subid("19_1278500530.77787") :method
-.annotate 'line', 3
-    $P59 = self."!PREFIX__!subrule"("ident", "")
-    new $P60, "ResizablePMCArray"
-    push $P60, $P59
-    .return ($P60)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "arg"  :subid("20_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx65_tgt
-    .local int rx65_pos
-    .local int rx65_off
-    .local int rx65_eos
-    .local int rx65_rep
-    .local pmc rx65_cur
-    (rx65_cur, rx65_pos, rx65_tgt) = self."!cursor_start"()
-    rx65_cur."!cursor_debug"("START ", "arg")
-    .lex unicode:"$\x{a2}", rx65_cur
-    .local pmc match
-    .lex "$/", match
-    length rx65_eos, rx65_tgt
-    gt rx65_pos, rx65_eos, rx65_done
-    set rx65_off, 0
-    lt rx65_pos, 2, rx65_start
-    sub rx65_off, rx65_pos, 1
-    substr rx65_tgt, rx65_tgt, rx65_off
-  rx65_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan68_done
-    goto rxscan68_scan
-  rxscan68_loop:
-    ($P10) = rx65_cur."from"()
-    inc $P10
-    set rx65_pos, $P10
-    ge rx65_pos, rx65_eos, rxscan68_done
-  rxscan68_scan:
-    set_addr $I10, rxscan68_loop
-    rx65_cur."!mark_push"(0, rx65_pos, $I10)
-  rxscan68_done:
-  alt69_0:
+.sub "!PREFIX__identifier"  :subid("19_1279529218.55263") :method
+.annotate 'line', 3
+    $P58 = self."!PREFIX__!subrule"("ident", "")
+    new $P59, "ResizablePMCArray"
+    push $P59, $P58
+    .return ($P59)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "arg"  :subid("20_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx63_tgt
+    .local int rx63_pos
+    .local int rx63_off
+    .local int rx63_eos
+    .local int rx63_rep
+    .local pmc rx63_cur
+    (rx63_cur, rx63_pos, rx63_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx63_cur
+    .local pmc match
+    .lex "$/", match
+    length rx63_eos, rx63_tgt
+    gt rx63_pos, rx63_eos, rx63_done
+    set rx63_off, 0
+    lt rx63_pos, 2, rx63_start
+    sub rx63_off, rx63_pos, 1
+    substr rx63_tgt, rx63_tgt, rx63_off
+  rx63_start:
+    eq $I10, 1, rx63_restart
+    rx63_cur."!cursor_debug"("START ", "arg")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan66_done
+    goto rxscan66_scan
+  rxscan66_loop:
+    ($P10) = rx63_cur."from"()
+    inc $P10
+    set rx63_pos, $P10
+    ge rx63_pos, rx63_eos, rxscan66_done
+  rxscan66_scan:
+    set_addr $I10, rxscan66_loop
+    rx63_cur."!mark_push"(0, rx63_pos, $I10)
+  rxscan66_done:
+  alt67_0:
 .annotate 'line', 15
-    set_addr $I10, alt69_1
-    rx65_cur."!mark_push"(0, rx65_pos, $I10)
+    set_addr $I10, alt67_1
+    rx63_cur."!mark_push"(0, rx63_pos, $I10)
 .annotate 'line', 16
   # rx enumcharlist negate=0 zerowidth
-    ge rx65_pos, rx65_eos, rx65_fail
-    sub $I10, rx65_pos, rx65_off
-    substr $S10, rx65_tgt, $I10, 1
+    ge rx63_pos, rx63_eos, rx63_fail
+    sub $I10, rx63_pos, rx63_off
+    substr $S10, rx63_tgt, $I10, 1
     index $I11, "'", $S10
-    lt $I11, 0, rx65_fail
+    lt $I11, 0, rx63_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx65_cur."!cursor_pos"(rx65_pos)
-    $P10 = rx65_cur."quote_EXPR"(":q")
-    unless $P10, rx65_fail
-    rx65_cur."!mark_push"(0, -1, 0, $P10)
+    rx63_cur."!cursor_pos"(rx63_pos)
+    $P10 = rx63_cur."quote_EXPR"(":q")
+    unless $P10, rx63_fail
+    rx63_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx65_pos = $P10."pos"()
-    goto alt69_end
-  alt69_1:
-    set_addr $I10, alt69_2
-    rx65_cur."!mark_push"(0, rx65_pos, $I10)
+    rx63_pos = $P10."pos"()
+    goto alt67_end
+  alt67_1:
+    set_addr $I10, alt67_2
+    rx63_cur."!mark_push"(0, rx63_pos, $I10)
 .annotate 'line', 17
   # rx enumcharlist negate=0 zerowidth
-    ge rx65_pos, rx65_eos, rx65_fail
-    sub $I10, rx65_pos, rx65_off
-    substr $S10, rx65_tgt, $I10, 1
+    ge rx63_pos, rx63_eos, rx63_fail
+    sub $I10, rx63_pos, rx63_off
+    substr $S10, rx63_tgt, $I10, 1
     index $I11, "\"", $S10
-    lt $I11, 0, rx65_fail
+    lt $I11, 0, rx63_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx65_cur."!cursor_pos"(rx65_pos)
-    $P10 = rx65_cur."quote_EXPR"(":qq")
-    unless $P10, rx65_fail
-    rx65_cur."!mark_push"(0, -1, 0, $P10)
+    rx63_cur."!cursor_pos"(rx63_pos)
+    $P10 = rx63_cur."quote_EXPR"(":qq")
+    unless $P10, rx63_fail
+    rx63_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx65_pos = $P10."pos"()
-    goto alt69_end
-  alt69_2:
+    rx63_pos = $P10."pos"()
+    goto alt67_end
+  alt67_2:
 .annotate 'line', 18
   # rx subcapture "val"
-    set_addr $I10, rxcap_70_fail
-    rx65_cur."!mark_push"(0, rx65_pos, $I10)
+    set_addr $I10, rxcap_68_fail
+    rx63_cur."!mark_push"(0, rx63_pos, $I10)
   # rx charclass_q d r 1..-1
-    sub $I10, rx65_pos, rx65_off
-    find_not_cclass $I11, 8, rx65_tgt, $I10, rx65_eos
+    sub $I10, rx63_pos, rx63_off
+    find_not_cclass $I11, 8, rx63_tgt, $I10, rx63_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx65_fail
-    add rx65_pos, rx65_off, $I11
-    set_addr $I10, rxcap_70_fail
-    ($I12, $I11) = rx65_cur."!mark_peek"($I10)
-    rx65_cur."!cursor_pos"($I11)
-    ($P10) = rx65_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx65_pos, "")
-    rx65_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx63_fail
+    add rx63_pos, rx63_off, $I11
+    set_addr $I10, rxcap_68_fail
+    ($I12, $I11) = rx63_cur."!mark_peek"($I10)
+    rx63_cur."!cursor_pos"($I11)
+    ($P10) = rx63_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx63_pos, "")
+    rx63_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("val")
-    goto rxcap_70_done
-  rxcap_70_fail:
-    goto rx65_fail
-  rxcap_70_done:
-  alt69_end:
+    goto rxcap_68_done
+  rxcap_68_fail:
+    goto rx63_fail
+  rxcap_68_done:
+  alt67_end:
 .annotate 'line', 14
   # rx pass
-    rx65_cur."!cursor_pass"(rx65_pos, "arg")
-    rx65_cur."!cursor_debug"("PASS  ", "arg", " at pos=", rx65_pos)
-    .return (rx65_cur)
-  rx65_fail:
+    rx63_cur."!cursor_pass"(rx63_pos, "arg")
+    rx63_cur."!cursor_debug"("PASS  ", "arg", " at pos=", rx63_pos)
+    .return (rx63_cur)
+  rx63_restart:
 .annotate 'line', 3
-    (rx65_rep, rx65_pos, $I10, $P10) = rx65_cur."!mark_fail"(0)
-    lt rx65_pos, -1, rx65_done
-    eq rx65_pos, -1, rx65_fail
+    rx63_cur."!cursor_debug"("NEXT ", "arg")
+  rx63_fail:
+    (rx63_rep, rx63_pos, $I10, $P10) = rx63_cur."!mark_fail"(0)
+    lt rx63_pos, -1, rx63_done
+    eq rx63_pos, -1, rx63_fail
     jump $I10
-  rx65_done:
-    rx65_cur."!cursor_fail"()
-    rx65_cur."!cursor_debug"("FAIL  ", "arg")
-    .return (rx65_cur)
+  rx63_done:
+    rx63_cur."!cursor_fail"()
+    rx63_cur."!cursor_debug"("FAIL  ", "arg")
+    .return (rx63_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__arg"  :subid("21_1278500530.77787") :method
+.sub "!PREFIX__arg"  :subid("21_1279529218.55263") :method
 .annotate 'line', 3
-    new $P67, "ResizablePMCArray"
-    push $P67, ""
-    push $P67, "\""
-    push $P67, "'"
-    .return ($P67)
+    new $P65, "ResizablePMCArray"
+    push $P65, ""
+    push $P65, "\""
+    push $P65, "'"
+    .return ($P65)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "arglist"  :subid("22_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "arglist"  :subid("22_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx72_tgt
-    .local int rx72_pos
-    .local int rx72_off
-    .local int rx72_eos
-    .local int rx72_rep
-    .local pmc rx72_cur
-    (rx72_cur, rx72_pos, rx72_tgt) = self."!cursor_start"()
-    rx72_cur."!cursor_debug"("START ", "arglist")
-    rx72_cur."!cursor_caparray"("arg")
-    .lex unicode:"$\x{a2}", rx72_cur
+    .local string rx70_tgt
+    .local int rx70_pos
+    .local int rx70_off
+    .local int rx70_eos
+    .local int rx70_rep
+    .local pmc rx70_cur
+    (rx70_cur, rx70_pos, rx70_tgt, $I10) = self."!cursor_start"()
+    rx70_cur."!cursor_caparray"("arg")
+    .lex unicode:"$\x{a2}", rx70_cur
     .local pmc match
     .lex "$/", match
-    length rx72_eos, rx72_tgt
-    gt rx72_pos, rx72_eos, rx72_done
-    set rx72_off, 0
-    lt rx72_pos, 2, rx72_start
-    sub rx72_off, rx72_pos, 1
-    substr rx72_tgt, rx72_tgt, rx72_off
-  rx72_start:
+    length rx70_eos, rx70_tgt
+    gt rx70_pos, rx70_eos, rx70_done
+    set rx70_off, 0
+    lt rx70_pos, 2, rx70_start
+    sub rx70_off, rx70_pos, 1
+    substr rx70_tgt, rx70_tgt, rx70_off
+  rx70_start:
+    eq $I10, 1, rx70_restart
+    rx70_cur."!cursor_debug"("START ", "arglist")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan76_done
-    goto rxscan76_scan
-  rxscan76_loop:
-    ($P10) = rx72_cur."from"()
+    ne $I10, -1, rxscan74_done
+    goto rxscan74_scan
+  rxscan74_loop:
+    ($P10) = rx70_cur."from"()
     inc $P10
-    set rx72_pos, $P10
-    ge rx72_pos, rx72_eos, rxscan76_done
-  rxscan76_scan:
-    set_addr $I10, rxscan76_loop
-    rx72_cur."!mark_push"(0, rx72_pos, $I10)
-  rxscan76_done:
+    set rx70_pos, $P10
+    ge rx70_pos, rx70_eos, rxscan74_done
+  rxscan74_scan:
+    set_addr $I10, rxscan74_loop
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
+  rxscan74_done:
 .annotate 'line', 22
   # rx subrule "ws" subtype=method negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."ws"()
-    unless $P10, rx72_fail
-    rx72_pos = $P10."pos"()
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."ws"()
+    unless $P10, rx70_fail
+    rx70_pos = $P10."pos"()
   # rx subrule "arg" subtype=capture negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."arg"()
-    unless $P10, rx72_fail
-    rx72_cur."!mark_push"(0, -1, 0, $P10)
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."arg"()
+    unless $P10, rx70_fail
+    rx70_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("arg")
-    rx72_pos = $P10."pos"()
+    rx70_pos = $P10."pos"()
   # rx subrule "ws" subtype=method negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."ws"()
-    unless $P10, rx72_fail
-    rx72_pos = $P10."pos"()
-  # rx rxquantr79 ** 0..*
-    set_addr $I82, rxquantr79_done
-    rx72_cur."!mark_push"(0, rx72_pos, $I82)
-  rxquantr79_loop:
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."ws"()
+    unless $P10, rx70_fail
+    rx70_pos = $P10."pos"()
+  # rx rxquantr77 ** 0..*
+    set_addr $I10, rxquantr77_done
+    rx70_cur."!mark_push"(0, rx70_pos, $I10)
+  rxquantr77_loop:
   # rx subrule "ws" subtype=method negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."ws"()
-    unless $P10, rx72_fail
-    rx72_pos = $P10."pos"()
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."ws"()
+    unless $P10, rx70_fail
+    rx70_pos = $P10."pos"()
   # rx literal  ","
-    add $I11, rx72_pos, 1
-    gt $I11, rx72_eos, rx72_fail
-    sub $I11, rx72_pos, rx72_off
-    substr $S10, rx72_tgt, $I11, 1
-    ne $S10, ",", rx72_fail
-    add rx72_pos, 1
+    add $I11, rx70_pos, 1
+    gt $I11, rx70_eos, rx70_fail
+    sub $I11, rx70_pos, rx70_off
+    substr $S10, rx70_tgt, $I11, 1
+    ne $S10, ",", rx70_fail
+    add rx70_pos, 1
   # rx subrule "ws" subtype=method negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."ws"()
-    unless $P10, rx72_fail
-    rx72_pos = $P10."pos"()
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."ws"()
+    unless $P10, rx70_fail
+    rx70_pos = $P10."pos"()
   # rx subrule "arg" subtype=capture negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."arg"()
-    unless $P10, rx72_fail
-    rx72_cur."!mark_push"(0, -1, 0, $P10)
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."arg"()
+    unless $P10, rx70_fail
+    rx70_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("arg")
-    rx72_pos = $P10."pos"()
-    (rx72_rep) = rx72_cur."!mark_commit"($I82)
-    rx72_cur."!mark_push"(rx72_rep, rx72_pos, $I82)
-    goto rxquantr79_loop
-  rxquantr79_done:
+    rx70_pos = $P10."pos"()
+    set_addr $I10, rxquantr77_done
+    (rx70_rep) = rx70_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr77_done
+    rx70_cur."!mark_push"(rx70_rep, rx70_pos, $I10)
+    goto rxquantr77_loop
+  rxquantr77_done:
   # rx subrule "ws" subtype=method negate=
-    rx72_cur."!cursor_pos"(rx72_pos)
-    $P10 = rx72_cur."ws"()
-    unless $P10, rx72_fail
-    rx72_pos = $P10."pos"()
+    rx70_cur."!cursor_pos"(rx70_pos)
+    $P10 = rx70_cur."ws"()
+    unless $P10, rx70_fail
+    rx70_pos = $P10."pos"()
   # rx pass
-    rx72_cur."!cursor_pass"(rx72_pos, "arglist")
-    rx72_cur."!cursor_debug"("PASS  ", "arglist", " at pos=", rx72_pos)
-    .return (rx72_cur)
-  rx72_fail:
+    rx70_cur."!cursor_pass"(rx70_pos, "arglist")
+    rx70_cur."!cursor_debug"("PASS  ", "arglist", " at pos=", rx70_pos)
+    .return (rx70_cur)
+  rx70_restart:
 .annotate 'line', 3
-    (rx72_rep, rx72_pos, $I10, $P10) = rx72_cur."!mark_fail"(0)
-    lt rx72_pos, -1, rx72_done
-    eq rx72_pos, -1, rx72_fail
+    rx70_cur."!cursor_debug"("NEXT ", "arglist")
+  rx70_fail:
+    (rx70_rep, rx70_pos, $I10, $P10) = rx70_cur."!mark_fail"(0)
+    lt rx70_pos, -1, rx70_done
+    eq rx70_pos, -1, rx70_fail
     jump $I10
-  rx72_done:
-    rx72_cur."!cursor_fail"()
-    rx72_cur."!cursor_debug"("FAIL  ", "arglist")
-    .return (rx72_cur)
+  rx70_done:
+    rx70_cur."!cursor_fail"()
+    rx70_cur."!cursor_debug"("FAIL  ", "arglist")
+    .return (rx70_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__arglist"  :subid("23_1278500530.77787") :method
+.sub "!PREFIX__arglist"  :subid("23_1279529218.55263") :method
 .annotate 'line', 3
-    $P74 = self."!PREFIX__!subrule"("ws", "")
-    new $P75, "ResizablePMCArray"
-    push $P75, $P74
-    .return ($P75)
+    $P72 = self."!PREFIX__!subrule"("ws", "")
+    new $P73, "ResizablePMCArray"
+    push $P73, $P72
+    .return ($P73)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "TOP"  :subid("24_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "TOP"  :subid("24_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx85_tgt
-    .local int rx85_pos
-    .local int rx85_off
-    .local int rx85_eos
-    .local int rx85_rep
-    .local pmc rx85_cur
-    (rx85_cur, rx85_pos, rx85_tgt) = self."!cursor_start"()
-    rx85_cur."!cursor_debug"("START ", "TOP")
-    .lex unicode:"$\x{a2}", rx85_cur
+    .local string rx82_tgt
+    .local int rx82_pos
+    .local int rx82_off
+    .local int rx82_eos
+    .local int rx82_rep
+    .local pmc rx82_cur
+    (rx82_cur, rx82_pos, rx82_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx82_cur
     .local pmc match
     .lex "$/", match
-    length rx85_eos, rx85_tgt
-    gt rx85_pos, rx85_eos, rx85_done
-    set rx85_off, 0
-    lt rx85_pos, 2, rx85_start
-    sub rx85_off, rx85_pos, 1
-    substr rx85_tgt, rx85_tgt, rx85_off
-  rx85_start:
+    length rx82_eos, rx82_tgt
+    gt rx82_pos, rx82_eos, rx82_done
+    set rx82_off, 0
+    lt rx82_pos, 2, rx82_start
+    sub rx82_off, rx82_pos, 1
+    substr rx82_tgt, rx82_tgt, rx82_off
+  rx82_start:
+    eq $I10, 1, rx82_restart
+    rx82_cur."!cursor_debug"("START ", "TOP")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan89_done
-    goto rxscan89_scan
-  rxscan89_loop:
-    ($P10) = rx85_cur."from"()
+    ne $I10, -1, rxscan86_done
+    goto rxscan86_scan
+  rxscan86_loop:
+    ($P10) = rx82_cur."from"()
     inc $P10
-    set rx85_pos, $P10
-    ge rx85_pos, rx85_eos, rxscan89_done
-  rxscan89_scan:
-    set_addr $I10, rxscan89_loop
-    rx85_cur."!mark_push"(0, rx85_pos, $I10)
-  rxscan89_done:
+    set rx82_pos, $P10
+    ge rx82_pos, rx82_eos, rxscan86_done
+  rxscan86_scan:
+    set_addr $I10, rxscan86_loop
+    rx82_cur."!mark_push"(0, rx82_pos, $I10)
+  rxscan86_done:
 .annotate 'line', 25
   # rx subrule "nibbler" subtype=capture negate=
-    rx85_cur."!cursor_pos"(rx85_pos)
-    $P10 = rx85_cur."nibbler"()
-    unless $P10, rx85_fail
-    rx85_cur."!mark_push"(0, -1, 0, $P10)
+    rx82_cur."!cursor_pos"(rx82_pos)
+    $P10 = rx82_cur."nibbler"()
+    unless $P10, rx82_fail
+    rx82_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("nibbler")
-    rx85_pos = $P10."pos"()
-  alt90_0:
+    rx82_pos = $P10."pos"()
+  alt87_0:
 .annotate 'line', 26
-    set_addr $I10, alt90_1
-    rx85_cur."!mark_push"(0, rx85_pos, $I10)
+    set_addr $I10, alt87_1
+    rx82_cur."!mark_push"(0, rx82_pos, $I10)
   # rxanchor eos
-    ne rx85_pos, rx85_eos, rx85_fail
-    goto alt90_end
-  alt90_1:
+    ne rx82_pos, rx82_eos, rx82_fail
+    goto alt87_end
+  alt87_1:
   # rx subrule "panic" subtype=method negate=
-    rx85_cur."!cursor_pos"(rx85_pos)
-    $P10 = rx85_cur."panic"("Confused")
-    unless $P10, rx85_fail
-    rx85_pos = $P10."pos"()
-  alt90_end:
+    rx82_cur."!cursor_pos"(rx82_pos)
+    $P10 = rx82_cur."panic"("Confused")
+    unless $P10, rx82_fail
+    rx82_pos = $P10."pos"()
+  alt87_end:
 .annotate 'line', 24
   # rx pass
-    rx85_cur."!cursor_pass"(rx85_pos, "TOP")
-    rx85_cur."!cursor_debug"("PASS  ", "TOP", " at pos=", rx85_pos)
-    .return (rx85_cur)
-  rx85_fail:
+    rx82_cur."!cursor_pass"(rx82_pos, "TOP")
+    rx82_cur."!cursor_debug"("PASS  ", "TOP", " at pos=", rx82_pos)
+    .return (rx82_cur)
+  rx82_restart:
 .annotate 'line', 3
-    (rx85_rep, rx85_pos, $I10, $P10) = rx85_cur."!mark_fail"(0)
-    lt rx85_pos, -1, rx85_done
-    eq rx85_pos, -1, rx85_fail
+    rx82_cur."!cursor_debug"("NEXT ", "TOP")
+  rx82_fail:
+    (rx82_rep, rx82_pos, $I10, $P10) = rx82_cur."!mark_fail"(0)
+    lt rx82_pos, -1, rx82_done
+    eq rx82_pos, -1, rx82_fail
     jump $I10
-  rx85_done:
-    rx85_cur."!cursor_fail"()
-    rx85_cur."!cursor_debug"("FAIL  ", "TOP")
-    .return (rx85_cur)
+  rx82_done:
+    rx82_cur."!cursor_fail"()
+    rx82_cur."!cursor_debug"("FAIL  ", "TOP")
+    .return (rx82_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__TOP"  :subid("25_1278500530.77787") :method
+.sub "!PREFIX__TOP"  :subid("25_1279529218.55263") :method
 .annotate 'line', 3
-    $P87 = self."!PREFIX__!subrule"("nibbler", "")
-    new $P88, "ResizablePMCArray"
-    push $P88, $P87
-    .return ($P88)
+    $P84 = self."!PREFIX__!subrule"("nibbler", "")
+    new $P85, "ResizablePMCArray"
+    push $P85, $P84
+    .return ($P85)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "nibbler"  :subid("26_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "nibbler"  :subid("26_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx92_tgt
-    .local int rx92_pos
-    .local int rx92_off
-    .local int rx92_eos
-    .local int rx92_rep
-    .local pmc rx92_cur
-    (rx92_cur, rx92_pos, rx92_tgt) = self."!cursor_start"()
-    rx92_cur."!cursor_debug"("START ", "nibbler")
-    rx92_cur."!cursor_caparray"("termish")
-    .lex unicode:"$\x{a2}", rx92_cur
+    .local string rx89_tgt
+    .local int rx89_pos
+    .local int rx89_off
+    .local int rx89_eos
+    .local int rx89_rep
+    .local pmc rx89_cur
+    (rx89_cur, rx89_pos, rx89_tgt, $I10) = self."!cursor_start"()
+    rx89_cur."!cursor_caparray"("termish")
+    .lex unicode:"$\x{a2}", rx89_cur
     .local pmc match
     .lex "$/", match
-    length rx92_eos, rx92_tgt
-    gt rx92_pos, rx92_eos, rx92_done
-    set rx92_off, 0
-    lt rx92_pos, 2, rx92_start
-    sub rx92_off, rx92_pos, 1
-    substr rx92_tgt, rx92_tgt, rx92_off
-  rx92_start:
+    length rx89_eos, rx89_tgt
+    gt rx89_pos, rx89_eos, rx89_done
+    set rx89_off, 0
+    lt rx89_pos, 2, rx89_start
+    sub rx89_off, rx89_pos, 1
+    substr rx89_tgt, rx89_tgt, rx89_off
+  rx89_start:
+    eq $I10, 1, rx89_restart
+    rx89_cur."!cursor_debug"("START ", "nibbler")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan95_done
-    goto rxscan95_scan
-  rxscan95_loop:
-    ($P10) = rx92_cur."from"()
+    ne $I10, -1, rxscan92_done
+    goto rxscan92_scan
+  rxscan92_loop:
+    ($P10) = rx89_cur."from"()
     inc $P10
-    set rx92_pos, $P10
-    ge rx92_pos, rx92_eos, rxscan95_done
-  rxscan95_scan:
-    set_addr $I10, rxscan95_loop
-    rx92_cur."!mark_push"(0, rx92_pos, $I10)
-  rxscan95_done:
+    set rx89_pos, $P10
+    ge rx89_pos, rx89_eos, rxscan92_done
+  rxscan92_scan:
+    set_addr $I10, rxscan92_loop
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
+  rxscan92_done:
 .annotate 'line', 30
   # rx reduce name="nibbler" key="open"
-    rx92_cur."!cursor_pos"(rx92_pos)
-    rx92_cur."!reduce"("nibbler", "open")
+    rx89_cur."!cursor_pos"(rx89_pos)
+    rx89_cur."!reduce"("nibbler", "open")
 .annotate 'line', 31
-  # rx rxquantr96 ** 0..1
-    set_addr $I98, rxquantr96_done
-    rx92_cur."!mark_push"(0, rx92_pos, $I98)
-  rxquantr96_loop:
+  # rx rxquantr93 ** 0..1
+    set_addr $I10, rxquantr93_done
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
+  rxquantr93_loop:
   # rx subrule "ws" subtype=method negate=
-    rx92_cur."!cursor_pos"(rx92_pos)
-    $P10 = rx92_cur."ws"()
-    unless $P10, rx92_fail
-    rx92_pos = $P10."pos"()
-  alt97_0:
-    set_addr $I10, alt97_1
-    rx92_cur."!mark_push"(0, rx92_pos, $I10)
+    rx89_cur."!cursor_pos"(rx89_pos)
+    $P10 = rx89_cur."ws"()
+    unless $P10, rx89_fail
+    rx89_pos = $P10."pos"()
+  alt94_0:
+    set_addr $I10, alt94_1
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
   # rx literal  "||"
-    add $I11, rx92_pos, 2
-    gt $I11, rx92_eos, rx92_fail
-    sub $I11, rx92_pos, rx92_off
-    substr $S10, rx92_tgt, $I11, 2
-    ne $S10, "||", rx92_fail
-    add rx92_pos, 2
-    goto alt97_end
-  alt97_1:
-    set_addr $I10, alt97_2
-    rx92_cur."!mark_push"(0, rx92_pos, $I10)
+    add $I11, rx89_pos, 2
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 2
+    ne $S10, "||", rx89_fail
+    add rx89_pos, 2
+    goto alt94_end
+  alt94_1:
+    set_addr $I10, alt94_2
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
   # rx literal  "|"
-    add $I11, rx92_pos, 1
-    gt $I11, rx92_eos, rx92_fail
-    sub $I11, rx92_pos, rx92_off
-    substr $S10, rx92_tgt, $I11, 1
-    ne $S10, "|", rx92_fail
-    add rx92_pos, 1
-    goto alt97_end
-  alt97_2:
-    set_addr $I10, alt97_3
-    rx92_cur."!mark_push"(0, rx92_pos, $I10)
+    add $I11, rx89_pos, 1
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 1
+    ne $S10, "|", rx89_fail
+    add rx89_pos, 1
+    goto alt94_end
+  alt94_2:
+    set_addr $I10, alt94_3
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
   # rx literal  "&&"
-    add $I11, rx92_pos, 2
-    gt $I11, rx92_eos, rx92_fail
-    sub $I11, rx92_pos, rx92_off
-    substr $S10, rx92_tgt, $I11, 2
-    ne $S10, "&&", rx92_fail
-    add rx92_pos, 2
-    goto alt97_end
-  alt97_3:
+    add $I11, rx89_pos, 2
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 2
+    ne $S10, "&&", rx89_fail
+    add rx89_pos, 2
+    goto alt94_end
+  alt94_3:
   # rx literal  "&"
-    add $I11, rx92_pos, 1
-    gt $I11, rx92_eos, rx92_fail
-    sub $I11, rx92_pos, rx92_off
-    substr $S10, rx92_tgt, $I11, 1
-    ne $S10, "&", rx92_fail
-    add rx92_pos, 1
-  alt97_end:
-    (rx92_rep) = rx92_cur."!mark_commit"($I98)
-  rxquantr96_done:
+    add $I11, rx89_pos, 1
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 1
+    ne $S10, "&", rx89_fail
+    add rx89_pos, 1
+  alt94_end:
+    set_addr $I10, rxquantr93_done
+    (rx89_rep) = rx89_cur."!mark_commit"($I10)
+  rxquantr93_done:
 .annotate 'line', 32
   # rx subrule "termish" subtype=capture negate=
-    rx92_cur."!cursor_pos"(rx92_pos)
-    $P10 = rx92_cur."termish"()
-    unless $P10, rx92_fail
-    rx92_cur."!mark_push"(0, -1, 0, $P10)
+    rx89_cur."!cursor_pos"(rx89_pos)
+    $P10 = rx89_cur."termish"()
+    unless $P10, rx89_fail
+    rx89_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("termish")
-    rx92_pos = $P10."pos"()
+    rx89_pos = $P10."pos"()
 .annotate 'line', 35
-  # rx rxquantr99 ** 0..*
-    set_addr $I102, rxquantr99_done
-    rx92_cur."!mark_push"(0, rx92_pos, $I102)
-  rxquantr99_loop:
-  alt100_0:
+  # rx rxquantr95 ** 0..*
+    set_addr $I10, rxquantr95_done
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
+  rxquantr95_loop:
+  alt96_0:
 .annotate 'line', 33
-    set_addr $I10, alt100_1
-    rx92_cur."!mark_push"(0, rx92_pos, $I10)
+    set_addr $I10, alt96_1
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
   # rx literal  "||"
-    add $I11, rx92_pos, 2
-    gt $I11, rx92_eos, rx92_fail
-    sub $I11, rx92_pos, rx92_off
-    substr $S10, rx92_tgt, $I11, 2
-    ne $S10, "||", rx92_fail
-    add rx92_pos, 2
-    goto alt100_end
-  alt100_1:
+    add $I11, rx89_pos, 2
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 2
+    ne $S10, "||", rx89_fail
+    add rx89_pos, 2
+    goto alt96_end
+  alt96_1:
   # rx literal  "|"
-    add $I11, rx92_pos, 1
-    gt $I11, rx92_eos, rx92_fail
-    sub $I11, rx92_pos, rx92_off
-    substr $S10, rx92_tgt, $I11, 1
-    ne $S10, "|", rx92_fail
-    add rx92_pos, 1
-  alt100_end:
-  alt101_0:
+    add $I11, rx89_pos, 1
+    gt $I11, rx89_eos, rx89_fail
+    sub $I11, rx89_pos, rx89_off
+    substr $S10, rx89_tgt, $I11, 1
+    ne $S10, "|", rx89_fail
+    add rx89_pos, 1
+  alt96_end:
+  alt97_0:
 .annotate 'line', 34
-    set_addr $I10, alt101_1
-    rx92_cur."!mark_push"(0, rx92_pos, $I10)
+    set_addr $I10, alt97_1
+    rx89_cur."!mark_push"(0, rx89_pos, $I10)
   # rx subrule "termish" subtype=capture negate=
-    rx92_cur."!cursor_pos"(rx92_pos)
-    $P10 = rx92_cur."termish"()
-    unless $P10, rx92_fail
-    rx92_cur."!mark_push"(0, -1, 0, $P10)
+    rx89_cur."!cursor_pos"(rx89_pos)
+    $P10 = rx89_cur."termish"()
+    unless $P10, rx89_fail
+    rx89_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("termish")
-    rx92_pos = $P10."pos"()
-    goto alt101_end
-  alt101_1:
+    rx89_pos = $P10."pos"()
+    goto alt97_end
+  alt97_1:
   # rx subrule "panic" subtype=method negate=
-    rx92_cur."!cursor_pos"(rx92_pos)
-    $P10 = rx92_cur."panic"("Null pattern not allowed")
-    unless $P10, rx92_fail
-    rx92_pos = $P10."pos"()
-  alt101_end:
+    rx89_cur."!cursor_pos"(rx89_pos)
+    $P10 = rx89_cur."panic"("Null pattern not allowed")
+    unless $P10, rx89_fail
+    rx89_pos = $P10."pos"()
+  alt97_end:
 .annotate 'line', 35
-    (rx92_rep) = rx92_cur."!mark_commit"($I102)
-    rx92_cur."!mark_push"(rx92_rep, rx92_pos, $I102)
-    goto rxquantr99_loop
-  rxquantr99_done:
+    set_addr $I10, rxquantr95_done
+    (rx89_rep) = rx89_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr95_done
+    rx89_cur."!mark_push"(rx89_rep, rx89_pos, $I10)
+    goto rxquantr95_loop
+  rxquantr95_done:
 .annotate 'line', 29
   # rx pass
-    rx92_cur."!cursor_pass"(rx92_pos, "nibbler")
-    rx92_cur."!cursor_debug"("PASS  ", "nibbler", " at pos=", rx92_pos)
-    .return (rx92_cur)
-  rx92_fail:
+    rx89_cur."!cursor_pass"(rx89_pos, "nibbler")
+    rx89_cur."!cursor_debug"("PASS  ", "nibbler", " at pos=", rx89_pos)
+    .return (rx89_cur)
+  rx89_restart:
 .annotate 'line', 3
-    (rx92_rep, rx92_pos, $I10, $P10) = rx92_cur."!mark_fail"(0)
-    lt rx92_pos, -1, rx92_done
-    eq rx92_pos, -1, rx92_fail
+    rx89_cur."!cursor_debug"("NEXT ", "nibbler")
+  rx89_fail:
+    (rx89_rep, rx89_pos, $I10, $P10) = rx89_cur."!mark_fail"(0)
+    lt rx89_pos, -1, rx89_done
+    eq rx89_pos, -1, rx89_fail
     jump $I10
-  rx92_done:
-    rx92_cur."!cursor_fail"()
-    rx92_cur."!cursor_debug"("FAIL  ", "nibbler")
-    .return (rx92_cur)
+  rx89_done:
+    rx89_cur."!cursor_fail"()
+    rx89_cur."!cursor_debug"("FAIL  ", "nibbler")
+    .return (rx89_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__nibbler"  :subid("27_1278500530.77787") :method
+.sub "!PREFIX__nibbler"  :subid("27_1279529218.55263") :method
 .annotate 'line', 3
-    new $P94, "ResizablePMCArray"
-    push $P94, ""
-    .return ($P94)
+    new $P91, "ResizablePMCArray"
+    push $P91, ""
+    .return ($P91)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "termish"  :subid("28_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "termish"  :subid("28_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx104_tgt
-    .local int rx104_pos
-    .local int rx104_off
-    .local int rx104_eos
-    .local int rx104_rep
-    .local pmc rx104_cur
-    (rx104_cur, rx104_pos, rx104_tgt) = self."!cursor_start"()
-    rx104_cur."!cursor_debug"("START ", "termish")
-    rx104_cur."!cursor_caparray"("noun")
-    .lex unicode:"$\x{a2}", rx104_cur
-    .local pmc match
-    .lex "$/", match
-    length rx104_eos, rx104_tgt
-    gt rx104_pos, rx104_eos, rx104_done
-    set rx104_off, 0
-    lt rx104_pos, 2, rx104_start
-    sub rx104_off, rx104_pos, 1
-    substr rx104_tgt, rx104_tgt, rx104_off
-  rx104_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan107_done
-    goto rxscan107_scan
-  rxscan107_loop:
-    ($P10) = rx104_cur."from"()
-    inc $P10
-    set rx104_pos, $P10
-    ge rx104_pos, rx104_eos, rxscan107_done
-  rxscan107_scan:
-    set_addr $I10, rxscan107_loop
-    rx104_cur."!mark_push"(0, rx104_pos, $I10)
-  rxscan107_done:
+    .local string rx99_tgt
+    .local int rx99_pos
+    .local int rx99_off
+    .local int rx99_eos
+    .local int rx99_rep
+    .local pmc rx99_cur
+    (rx99_cur, rx99_pos, rx99_tgt, $I10) = self."!cursor_start"()
+    rx99_cur."!cursor_caparray"("noun")
+    .lex unicode:"$\x{a2}", rx99_cur
+    .local pmc match
+    .lex "$/", match
+    length rx99_eos, rx99_tgt
+    gt rx99_pos, rx99_eos, rx99_done
+    set rx99_off, 0
+    lt rx99_pos, 2, rx99_start
+    sub rx99_off, rx99_pos, 1
+    substr rx99_tgt, rx99_tgt, rx99_off
+  rx99_start:
+    eq $I10, 1, rx99_restart
+    rx99_cur."!cursor_debug"("START ", "termish")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan102_done
+    goto rxscan102_scan
+  rxscan102_loop:
+    ($P10) = rx99_cur."from"()
+    inc $P10
+    set rx99_pos, $P10
+    ge rx99_pos, rx99_eos, rxscan102_done
+  rxscan102_scan:
+    set_addr $I10, rxscan102_loop
+    rx99_cur."!mark_push"(0, rx99_pos, $I10)
+  rxscan102_done:
 .annotate 'line', 39
-  # rx rxquantr108 ** 1..*
-    set_addr $I109, rxquantr108_done
-    rx104_cur."!mark_push"(0, -1, $I109)
-  rxquantr108_loop:
+  # rx rxquantr103 ** 1..*
+    set_addr $I10, rxquantr103_done
+    rx99_cur."!mark_push"(0, -1, $I10)
+  rxquantr103_loop:
   # rx subrule "quantified_atom" subtype=capture negate=
-    rx104_cur."!cursor_pos"(rx104_pos)
-    $P10 = rx104_cur."quantified_atom"()
-    unless $P10, rx104_fail
-    rx104_cur."!mark_push"(0, -1, 0, $P10)
+    rx99_cur."!cursor_pos"(rx99_pos)
+    $P10 = rx99_cur."quantified_atom"()
+    unless $P10, rx99_fail
+    goto rxsubrule104_pass
+  rxsubrule104_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx99_fail
+  rxsubrule104_pass:
+    set_addr $I10, rxsubrule104_back
+    rx99_cur."!mark_push"(0, rx99_pos, $I10, $P10)
     $P10."!cursor_names"("noun")
-    rx104_pos = $P10."pos"()
-    (rx104_rep) = rx104_cur."!mark_commit"($I109)
-    rx104_cur."!mark_push"(rx104_rep, rx104_pos, $I109)
-    goto rxquantr108_loop
-  rxquantr108_done:
+    rx99_pos = $P10."pos"()
+    set_addr $I10, rxquantr103_done
+    (rx99_rep) = rx99_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr103_done
+    rx99_cur."!mark_push"(rx99_rep, rx99_pos, $I10)
+    goto rxquantr103_loop
+  rxquantr103_done:
 .annotate 'line', 38
   # rx pass
-    rx104_cur."!cursor_pass"(rx104_pos, "termish")
-    rx104_cur."!cursor_debug"("PASS  ", "termish", " at pos=", rx104_pos)
-    .return (rx104_cur)
-  rx104_fail:
+    rx99_cur."!cursor_pass"(rx99_pos, "termish")
+    rx99_cur."!cursor_debug"("PASS  ", "termish", " at pos=", rx99_pos)
+    .return (rx99_cur)
+  rx99_restart:
 .annotate 'line', 3
-    (rx104_rep, rx104_pos, $I10, $P10) = rx104_cur."!mark_fail"(0)
-    lt rx104_pos, -1, rx104_done
-    eq rx104_pos, -1, rx104_fail
+    rx99_cur."!cursor_debug"("NEXT ", "termish")
+  rx99_fail:
+    (rx99_rep, rx99_pos, $I10, $P10) = rx99_cur."!mark_fail"(0)
+    lt rx99_pos, -1, rx99_done
+    eq rx99_pos, -1, rx99_fail
     jump $I10
-  rx104_done:
-    rx104_cur."!cursor_fail"()
-    rx104_cur."!cursor_debug"("FAIL  ", "termish")
-    .return (rx104_cur)
+  rx99_done:
+    rx99_cur."!cursor_fail"()
+    rx99_cur."!cursor_debug"("FAIL  ", "termish")
+    .return (rx99_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__termish"  :subid("29_1278500530.77787") :method
+.sub "!PREFIX__termish"  :subid("29_1279529218.55263") :method
 .annotate 'line', 3
-    new $P106, "ResizablePMCArray"
-    push $P106, ""
-    .return ($P106)
+    new $P101, "ResizablePMCArray"
+    push $P101, ""
+    .return ($P101)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "quantified_atom"  :subid("30_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "quantified_atom"  :subid("30_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .const 'Sub' $P119 = "32_1278500530.77787" 
-    capture_lex $P119
-    .local string rx111_tgt
-    .local int rx111_pos
-    .local int rx111_off
-    .local int rx111_eos
-    .local int rx111_rep
-    .local pmc rx111_cur
-    (rx111_cur, rx111_pos, rx111_tgt) = self."!cursor_start"()
-    rx111_cur."!cursor_debug"("START ", "quantified_atom")
-    rx111_cur."!cursor_caparray"("quantifier", "backmod")
-    .lex unicode:"$\x{a2}", rx111_cur
+    .const 'Sub' $P114 = "32_1279529218.55263" 
+    capture_lex $P114
+    .local string rx106_tgt
+    .local int rx106_pos
+    .local int rx106_off
+    .local int rx106_eos
+    .local int rx106_rep
+    .local pmc rx106_cur
+    (rx106_cur, rx106_pos, rx106_tgt, $I10) = self."!cursor_start"()
+    rx106_cur."!cursor_caparray"("quantifier", "backmod")
+    .lex unicode:"$\x{a2}", rx106_cur
     .local pmc match
     .lex "$/", match
-    length rx111_eos, rx111_tgt
-    gt rx111_pos, rx111_eos, rx111_done
-    set rx111_off, 0
-    lt rx111_pos, 2, rx111_start
-    sub rx111_off, rx111_pos, 1
-    substr rx111_tgt, rx111_tgt, rx111_off
-  rx111_start:
+    length rx106_eos, rx106_tgt
+    gt rx106_pos, rx106_eos, rx106_done
+    set rx106_off, 0
+    lt rx106_pos, 2, rx106_start
+    sub rx106_off, rx106_pos, 1
+    substr rx106_tgt, rx106_tgt, rx106_off
+  rx106_start:
+    eq $I10, 1, rx106_restart
+    rx106_cur."!cursor_debug"("START ", "quantified_atom")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan115_done
-    goto rxscan115_scan
-  rxscan115_loop:
-    ($P10) = rx111_cur."from"()
+    ne $I10, -1, rxscan110_done
+    goto rxscan110_scan
+  rxscan110_loop:
+    ($P10) = rx106_cur."from"()
     inc $P10
-    set rx111_pos, $P10
-    ge rx111_pos, rx111_eos, rxscan115_done
-  rxscan115_scan:
-    set_addr $I10, rxscan115_loop
-    rx111_cur."!mark_push"(0, rx111_pos, $I10)
-  rxscan115_done:
+    set rx106_pos, $P10
+    ge rx106_pos, rx106_eos, rxscan110_done
+  rxscan110_scan:
+    set_addr $I10, rxscan110_loop
+    rx106_cur."!mark_push"(0, rx106_pos, $I10)
+  rxscan110_done:
 .annotate 'line', 43
   # rx subrule "atom" subtype=capture negate=
-    rx111_cur."!cursor_pos"(rx111_pos)
-    $P10 = rx111_cur."atom"()
-    unless $P10, rx111_fail
-    rx111_cur."!mark_push"(0, -1, 0, $P10)
+    rx106_cur."!cursor_pos"(rx106_pos)
+    $P10 = rx106_cur."atom"()
+    unless $P10, rx106_fail
+    rx106_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("atom")
-    rx111_pos = $P10."pos"()
-  # rx rxquantr116 ** 0..1
-    set_addr $I122, rxquantr116_done
-    rx111_cur."!mark_push"(0, rx111_pos, $I122)
-  rxquantr116_loop:
+    rx106_pos = $P10."pos"()
+  # rx rxquantr111 ** 0..1
+    set_addr $I10, rxquantr111_done
+    rx106_cur."!mark_push"(0, rx106_pos, $I10)
+  rxquantr111_loop:
   # rx subrule "ws" subtype=method negate=
-    rx111_cur."!cursor_pos"(rx111_pos)
-    $P10 = rx111_cur."ws"()
-    unless $P10, rx111_fail
-    rx111_pos = $P10."pos"()
-  alt117_0:
-    set_addr $I10, alt117_1
-    rx111_cur."!mark_push"(0, rx111_pos, $I10)
+    rx106_cur."!cursor_pos"(rx106_pos)
+    $P10 = rx106_cur."ws"()
+    unless $P10, rx106_fail
+    rx106_pos = $P10."pos"()
+  alt112_0:
+    set_addr $I10, alt112_1
+    rx106_cur."!mark_push"(0, rx106_pos, $I10)
   # rx subrule "quantifier" subtype=capture negate=
-    rx111_cur."!cursor_pos"(rx111_pos)
-    $P10 = rx111_cur."quantifier"()
-    unless $P10, rx111_fail
-    rx111_cur."!mark_push"(0, -1, 0, $P10)
+    rx106_cur."!cursor_pos"(rx106_pos)
+    $P10 = rx106_cur."quantifier"()
+    unless $P10, rx106_fail
+    rx106_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quantifier")
-    rx111_pos = $P10."pos"()
-    goto alt117_end
-  alt117_1:
+    rx106_pos = $P10."pos"()
+    goto alt112_end
+  alt112_1:
   # rx subrule "before" subtype=zerowidth negate=
-    rx111_cur."!cursor_pos"(rx111_pos)
-    .const 'Sub' $P119 = "32_1278500530.77787" 
-    capture_lex $P119
-    $P10 = rx111_cur."before"($P119)
-    unless $P10, rx111_fail
+    rx106_cur."!cursor_pos"(rx106_pos)
+    .const 'Sub' $P114 = "32_1279529218.55263" 
+    capture_lex $P114
+    $P10 = rx106_cur."before"($P114)
+    unless $P10, rx106_fail
   # rx subrule "backmod" subtype=capture negate=
-    rx111_cur."!cursor_pos"(rx111_pos)
-    $P10 = rx111_cur."backmod"()
-    unless $P10, rx111_fail
-    rx111_cur."!mark_push"(0, -1, 0, $P10)
+    rx106_cur."!cursor_pos"(rx106_pos)
+    $P10 = rx106_cur."backmod"()
+    unless $P10, rx106_fail
+    rx106_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("backmod")
-    rx111_pos = $P10."pos"()
+    rx106_pos = $P10."pos"()
   # rx subrule "alpha" subtype=zerowidth negate=1
-    rx111_cur."!cursor_pos"(rx111_pos)
-    $P10 = rx111_cur."alpha"()
-    if $P10, rx111_fail
-  alt117_end:
-    (rx111_rep) = rx111_cur."!mark_commit"($I122)
-  rxquantr116_done:
+    rx106_cur."!cursor_pos"(rx106_pos)
+    $P10 = rx106_cur."alpha"()
+    if $P10, rx106_fail
+  alt112_end:
+    set_addr $I10, rxquantr111_done
+    (rx106_rep) = rx106_cur."!mark_commit"($I10)
+  rxquantr111_done:
 .annotate 'line', 42
   # rx pass
-    rx111_cur."!cursor_pass"(rx111_pos, "quantified_atom")
-    rx111_cur."!cursor_debug"("PASS  ", "quantified_atom", " at pos=", rx111_pos)
-    .return (rx111_cur)
-  rx111_fail:
+    rx106_cur."!cursor_pass"(rx106_pos, "quantified_atom")
+    rx106_cur."!cursor_debug"("PASS  ", "quantified_atom", " at pos=", rx106_pos)
+    .return (rx106_cur)
+  rx106_restart:
 .annotate 'line', 3
-    (rx111_rep, rx111_pos, $I10, $P10) = rx111_cur."!mark_fail"(0)
-    lt rx111_pos, -1, rx111_done
-    eq rx111_pos, -1, rx111_fail
+    rx106_cur."!cursor_debug"("NEXT ", "quantified_atom")
+  rx106_fail:
+    (rx106_rep, rx106_pos, $I10, $P10) = rx106_cur."!mark_fail"(0)
+    lt rx106_pos, -1, rx106_done
+    eq rx106_pos, -1, rx106_fail
     jump $I10
-  rx111_done:
-    rx111_cur."!cursor_fail"()
-    rx111_cur."!cursor_debug"("FAIL  ", "quantified_atom")
-    .return (rx111_cur)
+  rx106_done:
+    rx106_cur."!cursor_fail"()
+    rx106_cur."!cursor_debug"("FAIL  ", "quantified_atom")
+    .return (rx106_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__quantified_atom"  :subid("31_1278500530.77787") :method
+.sub "!PREFIX__quantified_atom"  :subid("31_1279529218.55263") :method
 .annotate 'line', 3
-    $P113 = self."!PREFIX__!subrule"("atom", "")
-    new $P114, "ResizablePMCArray"
-    push $P114, $P113
-    .return ($P114)
+    $P108 = self."!PREFIX__!subrule"("atom", "")
+    new $P109, "ResizablePMCArray"
+    push $P109, $P108
+    .return ($P109)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block118"  :anon :subid("32_1278500530.77787") :method :outer("30_1278500530.77787")
+.sub "_block113"  :anon :subid("32_1279529218.55263") :method :outer("30_1279529218.55263")
 .annotate 'line', 43
-    .local string rx120_tgt
-    .local int rx120_pos
-    .local int rx120_off
-    .local int rx120_eos
-    .local int rx120_rep
-    .local pmc rx120_cur
-    (rx120_cur, rx120_pos, rx120_tgt) = self."!cursor_start"()
-    rx120_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx120_cur
-    .local pmc match
-    .lex "$/", match
-    length rx120_eos, rx120_tgt
-    gt rx120_pos, rx120_eos, rx120_done
-    set rx120_off, 0
-    lt rx120_pos, 2, rx120_start
-    sub rx120_off, rx120_pos, 1
-    substr rx120_tgt, rx120_tgt, rx120_off
-  rx120_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan121_done
-    goto rxscan121_scan
-  rxscan121_loop:
-    ($P10) = rx120_cur."from"()
-    inc $P10
-    set rx120_pos, $P10
-    ge rx120_pos, rx120_eos, rxscan121_done
-  rxscan121_scan:
-    set_addr $I10, rxscan121_loop
-    rx120_cur."!mark_push"(0, rx120_pos, $I10)
-  rxscan121_done:
+    .local string rx115_tgt
+    .local int rx115_pos
+    .local int rx115_off
+    .local int rx115_eos
+    .local int rx115_rep
+    .local pmc rx115_cur
+    (rx115_cur, rx115_pos, rx115_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx115_cur
+    .local pmc match
+    .lex "$/", match
+    length rx115_eos, rx115_tgt
+    gt rx115_pos, rx115_eos, rx115_done
+    set rx115_off, 0
+    lt rx115_pos, 2, rx115_start
+    sub rx115_off, rx115_pos, 1
+    substr rx115_tgt, rx115_tgt, rx115_off
+  rx115_start:
+    eq $I10, 1, rx115_restart
+    rx115_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan116_done
+    goto rxscan116_scan
+  rxscan116_loop:
+    ($P10) = rx115_cur."from"()
+    inc $P10
+    set rx115_pos, $P10
+    ge rx115_pos, rx115_eos, rxscan116_done
+  rxscan116_scan:
+    set_addr $I10, rxscan116_loop
+    rx115_cur."!mark_push"(0, rx115_pos, $I10)
+  rxscan116_done:
   # rx literal  ":"
-    add $I11, rx120_pos, 1
-    gt $I11, rx120_eos, rx120_fail
-    sub $I11, rx120_pos, rx120_off
-    substr $S10, rx120_tgt, $I11, 1
-    ne $S10, ":", rx120_fail
-    add rx120_pos, 1
-  # rx pass
-    rx120_cur."!cursor_pass"(rx120_pos, "")
-    rx120_cur."!cursor_debug"("PASS  ", "", " at pos=", rx120_pos)
-    .return (rx120_cur)
-  rx120_fail:
-    (rx120_rep, rx120_pos, $I10, $P10) = rx120_cur."!mark_fail"(0)
-    lt rx120_pos, -1, rx120_done
-    eq rx120_pos, -1, rx120_fail
-    jump $I10
-  rx120_done:
-    rx120_cur."!cursor_fail"()
-    rx120_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx120_cur)
+    add $I11, rx115_pos, 1
+    gt $I11, rx115_eos, rx115_fail
+    sub $I11, rx115_pos, rx115_off
+    substr $S10, rx115_tgt, $I11, 1
+    ne $S10, ":", rx115_fail
+    add rx115_pos, 1
+  # rx pass
+    rx115_cur."!cursor_pass"(rx115_pos, "")
+    rx115_cur."!cursor_debug"("PASS  ", "", " at pos=", rx115_pos)
+    .return (rx115_cur)
+  rx115_restart:
+    rx115_cur."!cursor_debug"("NEXT ", "")
+  rx115_fail:
+    (rx115_rep, rx115_pos, $I10, $P10) = rx115_cur."!mark_fail"(0)
+    lt rx115_pos, -1, rx115_done
+    eq rx115_pos, -1, rx115_fail
+    jump $I10
+  rx115_done:
+    rx115_cur."!cursor_fail"()
+    rx115_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx115_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "atom"  :subid("33_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .const 'Sub' $P134 = "35_1278500530.77787" 
-    capture_lex $P134
-    .local string rx124_tgt
-    .local int rx124_pos
-    .local int rx124_off
-    .local int rx124_eos
-    .local int rx124_rep
-    .local pmc rx124_cur
-    (rx124_cur, rx124_pos, rx124_tgt) = self."!cursor_start"()
-    rx124_cur."!cursor_debug"("START ", "atom")
-    .lex unicode:"$\x{a2}", rx124_cur
-    .local pmc match
-    .lex "$/", match
-    length rx124_eos, rx124_tgt
-    gt rx124_pos, rx124_eos, rx124_done
-    set rx124_off, 0
-    lt rx124_pos, 2, rx124_start
-    sub rx124_off, rx124_pos, 1
-    substr rx124_tgt, rx124_tgt, rx124_off
-  rx124_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan128_done
-    goto rxscan128_scan
-  rxscan128_loop:
-    ($P10) = rx124_cur."from"()
-    inc $P10
-    set rx124_pos, $P10
-    ge rx124_pos, rx124_eos, rxscan128_done
-  rxscan128_scan:
-    set_addr $I10, rxscan128_loop
-    rx124_cur."!mark_push"(0, rx124_pos, $I10)
-  rxscan128_done:
-  alt129_0:
+.sub "atom"  :subid("33_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .const 'Sub' $P127 = "35_1279529218.55263" 
+    capture_lex $P127
+    .local string rx118_tgt
+    .local int rx118_pos
+    .local int rx118_off
+    .local int rx118_eos
+    .local int rx118_rep
+    .local pmc rx118_cur
+    (rx118_cur, rx118_pos, rx118_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx118_cur
+    .local pmc match
+    .lex "$/", match
+    length rx118_eos, rx118_tgt
+    gt rx118_pos, rx118_eos, rx118_done
+    set rx118_off, 0
+    lt rx118_pos, 2, rx118_start
+    sub rx118_off, rx118_pos, 1
+    substr rx118_tgt, rx118_tgt, rx118_off
+  rx118_start:
+    eq $I10, 1, rx118_restart
+    rx118_cur."!cursor_debug"("START ", "atom")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan122_done
+    goto rxscan122_scan
+  rxscan122_loop:
+    ($P10) = rx118_cur."from"()
+    inc $P10
+    set rx118_pos, $P10
+    ge rx118_pos, rx118_eos, rxscan122_done
+  rxscan122_scan:
+    set_addr $I10, rxscan122_loop
+    rx118_cur."!mark_push"(0, rx118_pos, $I10)
+  rxscan122_done:
+  alt123_0:
 .annotate 'line', 48
-    set_addr $I10, alt129_1
-    rx124_cur."!mark_push"(0, rx124_pos, $I10)
+    set_addr $I10, alt123_1
+    rx118_cur."!mark_push"(0, rx118_pos, $I10)
 .annotate 'line', 49
   # rx charclass w
-    ge rx124_pos, rx124_eos, rx124_fail
-    sub $I10, rx124_pos, rx124_off
-    is_cclass $I11, 8192, rx124_tgt, $I10
-    unless $I11, rx124_fail
-    inc rx124_pos
-  # rx rxquantr130 ** 0..1
-    set_addr $I137, rxquantr130_done
-    rx124_cur."!mark_push"(0, rx124_pos, $I137)
-  rxquantr130_loop:
-  # rx rxquantg131 ** 1..*
-    set_addr $I132, rxquantg131_done
-  rxquantg131_loop:
+    ge rx118_pos, rx118_eos, rx118_fail
+    sub $I10, rx118_pos, rx118_off
+    is_cclass $I11, 8192, rx118_tgt, $I10
+    unless $I11, rx118_fail
+    inc rx118_pos
+  # rx rxquantr124 ** 0..1
+    set_addr $I10, rxquantr124_done
+    rx118_cur."!mark_push"(0, rx118_pos, $I10)
+  rxquantr124_loop:
+  # rx rxquantg125 ** 1..*
+  rxquantg125_loop:
   # rx charclass w
-    ge rx124_pos, rx124_eos, rx124_fail
-    sub $I10, rx124_pos, rx124_off
-    is_cclass $I11, 8192, rx124_tgt, $I10
-    unless $I11, rx124_fail
-    inc rx124_pos
-    rx124_cur."!mark_push"(rx124_rep, rx124_pos, $I132)
-    goto rxquantg131_loop
-  rxquantg131_done:
+    ge rx118_pos, rx118_eos, rx118_fail
+    sub $I10, rx118_pos, rx118_off
+    is_cclass $I11, 8192, rx118_tgt, $I10
+    unless $I11, rx118_fail
+    inc rx118_pos
+    set_addr $I10, rxquantg125_done
+    rx118_cur."!mark_push"(rx118_rep, rx118_pos, $I10)
+    goto rxquantg125_loop
+  rxquantg125_done:
   # rx subrule "before" subtype=zerowidth negate=
-    rx124_cur."!cursor_pos"(rx124_pos)
-    .const 'Sub' $P134 = "35_1278500530.77787" 
-    capture_lex $P134
-    $P10 = rx124_cur."before"($P134)
-    unless $P10, rx124_fail
-    (rx124_rep) = rx124_cur."!mark_commit"($I137)
-  rxquantr130_done:
-    goto alt129_end
-  alt129_1:
+    rx118_cur."!cursor_pos"(rx118_pos)
+    .const 'Sub' $P127 = "35_1279529218.55263" 
+    capture_lex $P127
+    $P10 = rx118_cur."before"($P127)
+    unless $P10, rx118_fail
+    set_addr $I10, rxquantr124_done
+    (rx118_rep) = rx118_cur."!mark_commit"($I10)
+  rxquantr124_done:
+    goto alt123_end
+  alt123_1:
 .annotate 'line', 50
   # rx subrule "metachar" subtype=capture negate=
-    rx124_cur."!cursor_pos"(rx124_pos)
-    $P10 = rx124_cur."metachar"()
-    unless $P10, rx124_fail
-    rx124_cur."!mark_push"(0, -1, 0, $P10)
+    rx118_cur."!cursor_pos"(rx118_pos)
+    $P10 = rx118_cur."metachar"()
+    unless $P10, rx118_fail
+    rx118_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("metachar")
-    rx124_pos = $P10."pos"()
-  alt129_end:
+    rx118_pos = $P10."pos"()
+  alt123_end:
 .annotate 'line', 46
   # rx pass
-    rx124_cur."!cursor_pass"(rx124_pos, "atom")
-    rx124_cur."!cursor_debug"("PASS  ", "atom", " at pos=", rx124_pos)
-    .return (rx124_cur)
-  rx124_fail:
+    rx118_cur."!cursor_pass"(rx118_pos, "atom")
+    rx118_cur."!cursor_debug"("PASS  ", "atom", " at pos=", rx118_pos)
+    .return (rx118_cur)
+  rx118_restart:
 .annotate 'line', 3
-    (rx124_rep, rx124_pos, $I10, $P10) = rx124_cur."!mark_fail"(0)
-    lt rx124_pos, -1, rx124_done
-    eq rx124_pos, -1, rx124_fail
+    rx118_cur."!cursor_debug"("NEXT ", "atom")
+  rx118_fail:
+    (rx118_rep, rx118_pos, $I10, $P10) = rx118_cur."!mark_fail"(0)
+    lt rx118_pos, -1, rx118_done
+    eq rx118_pos, -1, rx118_fail
     jump $I10
-  rx124_done:
-    rx124_cur."!cursor_fail"()
-    rx124_cur."!cursor_debug"("FAIL  ", "atom")
-    .return (rx124_cur)
+  rx118_done:
+    rx118_cur."!cursor_fail"()
+    rx118_cur."!cursor_debug"("FAIL  ", "atom")
+    .return (rx118_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__atom"  :subid("34_1278500530.77787") :method
+.sub "!PREFIX__atom"  :subid("34_1279529218.55263") :method
 .annotate 'line', 3
-    $P126 = self."!PREFIX__!subrule"("metachar", "")
-    new $P127, "ResizablePMCArray"
-    push $P127, $P126
-    push $P127, ""
-    .return ($P127)
+    $P120 = self."!PREFIX__!subrule"("metachar", "")
+    new $P121, "ResizablePMCArray"
+    push $P121, $P120
+    push $P121, ""
+    .return ($P121)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block133"  :anon :subid("35_1278500530.77787") :method :outer("33_1278500530.77787")
+.sub "_block126"  :anon :subid("35_1279529218.55263") :method :outer("33_1279529218.55263")
 .annotate 'line', 49
+    .local string rx128_tgt
+    .local int rx128_pos
+    .local int rx128_off
+    .local int rx128_eos
+    .local int rx128_rep
+    .local pmc rx128_cur
+    (rx128_cur, rx128_pos, rx128_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx128_cur
+    .local pmc match
+    .lex "$/", match
+    length rx128_eos, rx128_tgt
+    gt rx128_pos, rx128_eos, rx128_done
+    set rx128_off, 0
+    lt rx128_pos, 2, rx128_start
+    sub rx128_off, rx128_pos, 1
+    substr rx128_tgt, rx128_tgt, rx128_off
+  rx128_start:
+    eq $I10, 1, rx128_restart
+    rx128_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan129_done
+    goto rxscan129_scan
+  rxscan129_loop:
+    ($P10) = rx128_cur."from"()
+    inc $P10
+    set rx128_pos, $P10
+    ge rx128_pos, rx128_eos, rxscan129_done
+  rxscan129_scan:
+    set_addr $I10, rxscan129_loop
+    rx128_cur."!mark_push"(0, rx128_pos, $I10)
+  rxscan129_done:
+  # rx charclass w
+    ge rx128_pos, rx128_eos, rx128_fail
+    sub $I10, rx128_pos, rx128_off
+    is_cclass $I11, 8192, rx128_tgt, $I10
+    unless $I11, rx128_fail
+    inc rx128_pos
+  # rx pass
+    rx128_cur."!cursor_pass"(rx128_pos, "")
+    rx128_cur."!cursor_debug"("PASS  ", "", " at pos=", rx128_pos)
+    .return (rx128_cur)
+  rx128_restart:
+    rx128_cur."!cursor_debug"("NEXT ", "")
+  rx128_fail:
+    (rx128_rep, rx128_pos, $I10, $P10) = rx128_cur."!mark_fail"(0)
+    lt rx128_pos, -1, rx128_done
+    eq rx128_pos, -1, rx128_fail
+    jump $I10
+  rx128_done:
+    rx128_cur."!cursor_fail"()
+    rx128_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx128_cur)
+    .return ()
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "quantifier"  :subid("36_1279529218.55263") :method
+.annotate 'line', 54
+    $P131 = self."!protoregex"("quantifier")
+    .return ($P131)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "!PREFIX__quantifier"  :subid("37_1279529218.55263") :method
+.annotate 'line', 54
+    $P133 = self."!PREFIX__!protoregex"("quantifier")
+    .return ($P133)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "quantifier:sym<*>"  :subid("38_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
     .local string rx135_tgt
     .local int rx135_pos
     .local int rx135_off
     .local int rx135_eos
     .local int rx135_rep
     .local pmc rx135_cur
-    (rx135_cur, rx135_pos, rx135_tgt) = self."!cursor_start"()
-    rx135_cur."!cursor_debug"("START ", "")
+    (rx135_cur, rx135_pos, rx135_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx135_cur
     .local pmc match
     .lex "$/", match
@@ -1446,28 +1575,56 @@
     sub rx135_off, rx135_pos, 1
     substr rx135_tgt, rx135_tgt, rx135_off
   rx135_start:
+    eq $I10, 1, rx135_restart
+    rx135_cur."!cursor_debug"("START ", "quantifier:sym<*>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan136_done
-    goto rxscan136_scan
-  rxscan136_loop:
+    ne $I10, -1, rxscan139_done
+    goto rxscan139_scan
+  rxscan139_loop:
     ($P10) = rx135_cur."from"()
     inc $P10
     set rx135_pos, $P10
-    ge rx135_pos, rx135_eos, rxscan136_done
-  rxscan136_scan:
-    set_addr $I10, rxscan136_loop
+    ge rx135_pos, rx135_eos, rxscan139_done
+  rxscan139_scan:
+    set_addr $I10, rxscan139_loop
     rx135_cur."!mark_push"(0, rx135_pos, $I10)
-  rxscan136_done:
-  # rx charclass w
-    ge rx135_pos, rx135_eos, rx135_fail
-    sub $I10, rx135_pos, rx135_off
-    is_cclass $I11, 8192, rx135_tgt, $I10
-    unless $I11, rx135_fail
-    inc rx135_pos
+  rxscan139_done:
+.annotate 'line', 55
+  # rx subcapture "sym"
+    set_addr $I10, rxcap_140_fail
+    rx135_cur."!mark_push"(0, rx135_pos, $I10)
+  # rx literal  "*"
+    add $I11, rx135_pos, 1
+    gt $I11, rx135_eos, rx135_fail
+    sub $I11, rx135_pos, rx135_off
+    substr $S10, rx135_tgt, $I11, 1
+    ne $S10, "*", rx135_fail
+    add rx135_pos, 1
+    set_addr $I10, rxcap_140_fail
+    ($I12, $I11) = rx135_cur."!mark_peek"($I10)
+    rx135_cur."!cursor_pos"($I11)
+    ($P10) = rx135_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx135_pos, "")
+    rx135_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("sym")
+    goto rxcap_140_done
+  rxcap_140_fail:
+    goto rx135_fail
+  rxcap_140_done:
+  # rx subrule "backmod" subtype=capture negate=
+    rx135_cur."!cursor_pos"(rx135_pos)
+    $P10 = rx135_cur."backmod"()
+    unless $P10, rx135_fail
+    rx135_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("backmod")
+    rx135_pos = $P10."pos"()
   # rx pass
-    rx135_cur."!cursor_pass"(rx135_pos, "")
-    rx135_cur."!cursor_debug"("PASS  ", "", " at pos=", rx135_pos)
+    rx135_cur."!cursor_pass"(rx135_pos, "quantifier:sym<*>")
+    rx135_cur."!cursor_debug"("PASS  ", "quantifier:sym<*>", " at pos=", rx135_pos)
     .return (rx135_cur)
+  rx135_restart:
+.annotate 'line', 3
+    rx135_cur."!cursor_debug"("NEXT ", "quantifier:sym<*>")
   rx135_fail:
     (rx135_rep, rx135_pos, $I10, $P10) = rx135_cur."!mark_fail"(0)
     lt rx135_pos, -1, rx135_done
@@ -1475,3986 +1632,4220 @@
     jump $I10
   rx135_done:
     rx135_cur."!cursor_fail"()
-    rx135_cur."!cursor_debug"("FAIL  ", "")
+    rx135_cur."!cursor_debug"("FAIL  ", "quantifier:sym<*>")
     .return (rx135_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "quantifier"  :subid("36_1278500530.77787") :method
-.annotate 'line', 54
-    $P139 = self."!protoregex"("quantifier")
-    .return ($P139)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__quantifier"  :subid("37_1278500530.77787") :method
-.annotate 'line', 54
-    $P141 = self."!PREFIX__!protoregex"("quantifier")
-    .return ($P141)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "quantifier:sym<*>"  :subid("38_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx143_tgt
-    .local int rx143_pos
-    .local int rx143_off
-    .local int rx143_eos
-    .local int rx143_rep
-    .local pmc rx143_cur
-    (rx143_cur, rx143_pos, rx143_tgt) = self."!cursor_start"()
-    rx143_cur."!cursor_debug"("START ", "quantifier:sym<*>")
-    .lex unicode:"$\x{a2}", rx143_cur
-    .local pmc match
-    .lex "$/", match
-    length rx143_eos, rx143_tgt
-    gt rx143_pos, rx143_eos, rx143_done
-    set rx143_off, 0
-    lt rx143_pos, 2, rx143_start
-    sub rx143_off, rx143_pos, 1
-    substr rx143_tgt, rx143_tgt, rx143_off
-  rx143_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan147_done
-    goto rxscan147_scan
-  rxscan147_loop:
-    ($P10) = rx143_cur."from"()
-    inc $P10
-    set rx143_pos, $P10
-    ge rx143_pos, rx143_eos, rxscan147_done
-  rxscan147_scan:
-    set_addr $I10, rxscan147_loop
-    rx143_cur."!mark_push"(0, rx143_pos, $I10)
-  rxscan147_done:
-.annotate 'line', 55
-  # rx subcapture "sym"
-    set_addr $I10, rxcap_148_fail
-    rx143_cur."!mark_push"(0, rx143_pos, $I10)
-  # rx literal  "*"
-    add $I11, rx143_pos, 1
-    gt $I11, rx143_eos, rx143_fail
-    sub $I11, rx143_pos, rx143_off
-    substr $S10, rx143_tgt, $I11, 1
-    ne $S10, "*", rx143_fail
-    add rx143_pos, 1
-    set_addr $I10, rxcap_148_fail
-    ($I12, $I11) = rx143_cur."!mark_peek"($I10)
-    rx143_cur."!cursor_pos"($I11)
-    ($P10) = rx143_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx143_pos, "")
-    rx143_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("sym")
-    goto rxcap_148_done
-  rxcap_148_fail:
-    goto rx143_fail
-  rxcap_148_done:
-  # rx subrule "backmod" subtype=capture negate=
-    rx143_cur."!cursor_pos"(rx143_pos)
-    $P10 = rx143_cur."backmod"()
-    unless $P10, rx143_fail
-    rx143_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("backmod")
-    rx143_pos = $P10."pos"()
-  # rx pass
-    rx143_cur."!cursor_pass"(rx143_pos, "quantifier:sym<*>")
-    rx143_cur."!cursor_debug"("PASS  ", "quantifier:sym<*>", " at pos=", rx143_pos)
-    .return (rx143_cur)
-  rx143_fail:
-.annotate 'line', 3
-    (rx143_rep, rx143_pos, $I10, $P10) = rx143_cur."!mark_fail"(0)
-    lt rx143_pos, -1, rx143_done
-    eq rx143_pos, -1, rx143_fail
-    jump $I10
-  rx143_done:
-    rx143_cur."!cursor_fail"()
-    rx143_cur."!cursor_debug"("FAIL  ", "quantifier:sym<*>")
-    .return (rx143_cur)
-    .return ()
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__quantifier:sym<*>"  :subid("39_1278500530.77787") :method
+.sub "!PREFIX__quantifier:sym<*>"  :subid("39_1279529218.55263") :method
 .annotate 'line', 3
-    $P145 = self."!PREFIX__!subrule"("backmod", "*")
-    new $P146, "ResizablePMCArray"
-    push $P146, $P145
-    .return ($P146)
+    $P137 = self."!PREFIX__!subrule"("backmod", "*")
+    new $P138, "ResizablePMCArray"
+    push $P138, $P137
+    .return ($P138)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "quantifier:sym<+>"  :subid("40_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx150_tgt
-    .local int rx150_pos
-    .local int rx150_off
-    .local int rx150_eos
-    .local int rx150_rep
-    .local pmc rx150_cur
-    (rx150_cur, rx150_pos, rx150_tgt) = self."!cursor_start"()
-    rx150_cur."!cursor_debug"("START ", "quantifier:sym<+>")
-    .lex unicode:"$\x{a2}", rx150_cur
-    .local pmc match
-    .lex "$/", match
-    length rx150_eos, rx150_tgt
-    gt rx150_pos, rx150_eos, rx150_done
-    set rx150_off, 0
-    lt rx150_pos, 2, rx150_start
-    sub rx150_off, rx150_pos, 1
-    substr rx150_tgt, rx150_tgt, rx150_off
-  rx150_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan154_done
-    goto rxscan154_scan
-  rxscan154_loop:
-    ($P10) = rx150_cur."from"()
-    inc $P10
-    set rx150_pos, $P10
-    ge rx150_pos, rx150_eos, rxscan154_done
-  rxscan154_scan:
-    set_addr $I10, rxscan154_loop
-    rx150_cur."!mark_push"(0, rx150_pos, $I10)
-  rxscan154_done:
+.sub "quantifier:sym<+>"  :subid("40_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx142_tgt
+    .local int rx142_pos
+    .local int rx142_off
+    .local int rx142_eos
+    .local int rx142_rep
+    .local pmc rx142_cur
+    (rx142_cur, rx142_pos, rx142_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx142_cur
+    .local pmc match
+    .lex "$/", match
+    length rx142_eos, rx142_tgt
+    gt rx142_pos, rx142_eos, rx142_done
+    set rx142_off, 0
+    lt rx142_pos, 2, rx142_start
+    sub rx142_off, rx142_pos, 1
+    substr rx142_tgt, rx142_tgt, rx142_off
+  rx142_start:
+    eq $I10, 1, rx142_restart
+    rx142_cur."!cursor_debug"("START ", "quantifier:sym<+>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan146_done
+    goto rxscan146_scan
+  rxscan146_loop:
+    ($P10) = rx142_cur."from"()
+    inc $P10
+    set rx142_pos, $P10
+    ge rx142_pos, rx142_eos, rxscan146_done
+  rxscan146_scan:
+    set_addr $I10, rxscan146_loop
+    rx142_cur."!mark_push"(0, rx142_pos, $I10)
+  rxscan146_done:
 .annotate 'line', 56
   # rx subcapture "sym"
-    set_addr $I10, rxcap_155_fail
-    rx150_cur."!mark_push"(0, rx150_pos, $I10)
+    set_addr $I10, rxcap_147_fail
+    rx142_cur."!mark_push"(0, rx142_pos, $I10)
   # rx literal  "+"
-    add $I11, rx150_pos, 1
-    gt $I11, rx150_eos, rx150_fail
-    sub $I11, rx150_pos, rx150_off
-    substr $S10, rx150_tgt, $I11, 1
-    ne $S10, "+", rx150_fail
-    add rx150_pos, 1
-    set_addr $I10, rxcap_155_fail
-    ($I12, $I11) = rx150_cur."!mark_peek"($I10)
-    rx150_cur."!cursor_pos"($I11)
-    ($P10) = rx150_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx150_pos, "")
-    rx150_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx142_pos, 1
+    gt $I11, rx142_eos, rx142_fail
+    sub $I11, rx142_pos, rx142_off
+    substr $S10, rx142_tgt, $I11, 1
+    ne $S10, "+", rx142_fail
+    add rx142_pos, 1
+    set_addr $I10, rxcap_147_fail
+    ($I12, $I11) = rx142_cur."!mark_peek"($I10)
+    rx142_cur."!cursor_pos"($I11)
+    ($P10) = rx142_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx142_pos, "")
+    rx142_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_155_done
-  rxcap_155_fail:
-    goto rx150_fail
-  rxcap_155_done:
+    goto rxcap_147_done
+  rxcap_147_fail:
+    goto rx142_fail
+  rxcap_147_done:
   # rx subrule "backmod" subtype=capture negate=
-    rx150_cur."!cursor_pos"(rx150_pos)
-    $P10 = rx150_cur."backmod"()
-    unless $P10, rx150_fail
-    rx150_cur."!mark_push"(0, -1, 0, $P10)
+    rx142_cur."!cursor_pos"(rx142_pos)
+    $P10 = rx142_cur."backmod"()
+    unless $P10, rx142_fail
+    rx142_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("backmod")
-    rx150_pos = $P10."pos"()
+    rx142_pos = $P10."pos"()
   # rx pass
-    rx150_cur."!cursor_pass"(rx150_pos, "quantifier:sym<+>")
-    rx150_cur."!cursor_debug"("PASS  ", "quantifier:sym<+>", " at pos=", rx150_pos)
-    .return (rx150_cur)
-  rx150_fail:
+    rx142_cur."!cursor_pass"(rx142_pos, "quantifier:sym<+>")
+    rx142_cur."!cursor_debug"("PASS  ", "quantifier:sym<+>", " at pos=", rx142_pos)
+    .return (rx142_cur)
+  rx142_restart:
 .annotate 'line', 3
-    (rx150_rep, rx150_pos, $I10, $P10) = rx150_cur."!mark_fail"(0)
-    lt rx150_pos, -1, rx150_done
-    eq rx150_pos, -1, rx150_fail
+    rx142_cur."!cursor_debug"("NEXT ", "quantifier:sym<+>")
+  rx142_fail:
+    (rx142_rep, rx142_pos, $I10, $P10) = rx142_cur."!mark_fail"(0)
+    lt rx142_pos, -1, rx142_done
+    eq rx142_pos, -1, rx142_fail
     jump $I10
-  rx150_done:
-    rx150_cur."!cursor_fail"()
-    rx150_cur."!cursor_debug"("FAIL  ", "quantifier:sym<+>")
-    .return (rx150_cur)
+  rx142_done:
+    rx142_cur."!cursor_fail"()
+    rx142_cur."!cursor_debug"("FAIL  ", "quantifier:sym<+>")
+    .return (rx142_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__quantifier:sym<+>"  :subid("41_1278500530.77787") :method
+.sub "!PREFIX__quantifier:sym<+>"  :subid("41_1279529218.55263") :method
 .annotate 'line', 3
-    $P152 = self."!PREFIX__!subrule"("backmod", "+")
-    new $P153, "ResizablePMCArray"
-    push $P153, $P152
-    .return ($P153)
+    $P144 = self."!PREFIX__!subrule"("backmod", "+")
+    new $P145, "ResizablePMCArray"
+    push $P145, $P144
+    .return ($P145)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "quantifier:sym<?>"  :subid("42_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "quantifier:sym<?>"  :subid("42_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx157_tgt
-    .local int rx157_pos
-    .local int rx157_off
-    .local int rx157_eos
-    .local int rx157_rep
-    .local pmc rx157_cur
-    (rx157_cur, rx157_pos, rx157_tgt) = self."!cursor_start"()
-    rx157_cur."!cursor_debug"("START ", "quantifier:sym<?>")
-    .lex unicode:"$\x{a2}", rx157_cur
+    .local string rx149_tgt
+    .local int rx149_pos
+    .local int rx149_off
+    .local int rx149_eos
+    .local int rx149_rep
+    .local pmc rx149_cur
+    (rx149_cur, rx149_pos, rx149_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx149_cur
     .local pmc match
     .lex "$/", match
-    length rx157_eos, rx157_tgt
-    gt rx157_pos, rx157_eos, rx157_done
-    set rx157_off, 0
-    lt rx157_pos, 2, rx157_start
-    sub rx157_off, rx157_pos, 1
-    substr rx157_tgt, rx157_tgt, rx157_off
-  rx157_start:
+    length rx149_eos, rx149_tgt
+    gt rx149_pos, rx149_eos, rx149_done
+    set rx149_off, 0
+    lt rx149_pos, 2, rx149_start
+    sub rx149_off, rx149_pos, 1
+    substr rx149_tgt, rx149_tgt, rx149_off
+  rx149_start:
+    eq $I10, 1, rx149_restart
+    rx149_cur."!cursor_debug"("START ", "quantifier:sym<?>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan161_done
-    goto rxscan161_scan
-  rxscan161_loop:
-    ($P10) = rx157_cur."from"()
+    ne $I10, -1, rxscan153_done
+    goto rxscan153_scan
+  rxscan153_loop:
+    ($P10) = rx149_cur."from"()
     inc $P10
-    set rx157_pos, $P10
-    ge rx157_pos, rx157_eos, rxscan161_done
-  rxscan161_scan:
-    set_addr $I10, rxscan161_loop
-    rx157_cur."!mark_push"(0, rx157_pos, $I10)
-  rxscan161_done:
+    set rx149_pos, $P10
+    ge rx149_pos, rx149_eos, rxscan153_done
+  rxscan153_scan:
+    set_addr $I10, rxscan153_loop
+    rx149_cur."!mark_push"(0, rx149_pos, $I10)
+  rxscan153_done:
 .annotate 'line', 57
   # rx subcapture "sym"
-    set_addr $I10, rxcap_162_fail
-    rx157_cur."!mark_push"(0, rx157_pos, $I10)
+    set_addr $I10, rxcap_154_fail
+    rx149_cur."!mark_push"(0, rx149_pos, $I10)
   # rx literal  "?"
-    add $I11, rx157_pos, 1
-    gt $I11, rx157_eos, rx157_fail
-    sub $I11, rx157_pos, rx157_off
-    substr $S10, rx157_tgt, $I11, 1
-    ne $S10, "?", rx157_fail
-    add rx157_pos, 1
-    set_addr $I10, rxcap_162_fail
-    ($I12, $I11) = rx157_cur."!mark_peek"($I10)
-    rx157_cur."!cursor_pos"($I11)
-    ($P10) = rx157_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx157_pos, "")
-    rx157_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx149_pos, 1
+    gt $I11, rx149_eos, rx149_fail
+    sub $I11, rx149_pos, rx149_off
+    substr $S10, rx149_tgt, $I11, 1
+    ne $S10, "?", rx149_fail
+    add rx149_pos, 1
+    set_addr $I10, rxcap_154_fail
+    ($I12, $I11) = rx149_cur."!mark_peek"($I10)
+    rx149_cur."!cursor_pos"($I11)
+    ($P10) = rx149_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx149_pos, "")
+    rx149_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_162_done
-  rxcap_162_fail:
-    goto rx157_fail
-  rxcap_162_done:
+    goto rxcap_154_done
+  rxcap_154_fail:
+    goto rx149_fail
+  rxcap_154_done:
   # rx subrule "backmod" subtype=capture negate=
-    rx157_cur."!cursor_pos"(rx157_pos)
-    $P10 = rx157_cur."backmod"()
-    unless $P10, rx157_fail
-    rx157_cur."!mark_push"(0, -1, 0, $P10)
+    rx149_cur."!cursor_pos"(rx149_pos)
+    $P10 = rx149_cur."backmod"()
+    unless $P10, rx149_fail
+    rx149_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("backmod")
-    rx157_pos = $P10."pos"()
+    rx149_pos = $P10."pos"()
   # rx pass
-    rx157_cur."!cursor_pass"(rx157_pos, "quantifier:sym<?>")
-    rx157_cur."!cursor_debug"("PASS  ", "quantifier:sym<?>", " at pos=", rx157_pos)
-    .return (rx157_cur)
-  rx157_fail:
+    rx149_cur."!cursor_pass"(rx149_pos, "quantifier:sym<?>")
+    rx149_cur."!cursor_debug"("PASS  ", "quantifier:sym<?>", " at pos=", rx149_pos)
+    .return (rx149_cur)
+  rx149_restart:
 .annotate 'line', 3
-    (rx157_rep, rx157_pos, $I10, $P10) = rx157_cur."!mark_fail"(0)
-    lt rx157_pos, -1, rx157_done
-    eq rx157_pos, -1, rx157_fail
+    rx149_cur."!cursor_debug"("NEXT ", "quantifier:sym<?>")
+  rx149_fail:
+    (rx149_rep, rx149_pos, $I10, $P10) = rx149_cur."!mark_fail"(0)
+    lt rx149_pos, -1, rx149_done
+    eq rx149_pos, -1, rx149_fail
     jump $I10
-  rx157_done:
-    rx157_cur."!cursor_fail"()
-    rx157_cur."!cursor_debug"("FAIL  ", "quantifier:sym<?>")
-    .return (rx157_cur)
+  rx149_done:
+    rx149_cur."!cursor_fail"()
+    rx149_cur."!cursor_debug"("FAIL  ", "quantifier:sym<?>")
+    .return (rx149_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__quantifier:sym<?>"  :subid("43_1278500530.77787") :method
+.sub "!PREFIX__quantifier:sym<?>"  :subid("43_1279529218.55263") :method
 .annotate 'line', 3
-    $P159 = self."!PREFIX__!subrule"("backmod", "?")
-    new $P160, "ResizablePMCArray"
-    push $P160, $P159
-    .return ($P160)
+    $P151 = self."!PREFIX__!subrule"("backmod", "?")
+    new $P152, "ResizablePMCArray"
+    push $P152, $P151
+    .return ($P152)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "quantifier:sym<**>"  :subid("44_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "quantifier:sym<**>"  :subid("44_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx164_tgt
-    .local int rx164_pos
-    .local int rx164_off
-    .local int rx164_eos
-    .local int rx164_rep
-    .local pmc rx164_cur
-    (rx164_cur, rx164_pos, rx164_tgt) = self."!cursor_start"()
-    rx164_cur."!cursor_debug"("START ", "quantifier:sym<**>")
-    rx164_cur."!cursor_caparray"("normspace", "max")
-    .lex unicode:"$\x{a2}", rx164_cur
-    .local pmc match
-    .lex "$/", match
-    length rx164_eos, rx164_tgt
-    gt rx164_pos, rx164_eos, rx164_done
-    set rx164_off, 0
-    lt rx164_pos, 2, rx164_start
-    sub rx164_off, rx164_pos, 1
-    substr rx164_tgt, rx164_tgt, rx164_off
-  rx164_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan167_done
-    goto rxscan167_scan
-  rxscan167_loop:
-    ($P10) = rx164_cur."from"()
-    inc $P10
-    set rx164_pos, $P10
-    ge rx164_pos, rx164_eos, rxscan167_done
-  rxscan167_scan:
-    set_addr $I10, rxscan167_loop
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
-  rxscan167_done:
+    .local string rx156_tgt
+    .local int rx156_pos
+    .local int rx156_off
+    .local int rx156_eos
+    .local int rx156_rep
+    .local pmc rx156_cur
+    (rx156_cur, rx156_pos, rx156_tgt, $I10) = self."!cursor_start"()
+    rx156_cur."!cursor_caparray"("normspace", "max")
+    .lex unicode:"$\x{a2}", rx156_cur
+    .local pmc match
+    .lex "$/", match
+    length rx156_eos, rx156_tgt
+    gt rx156_pos, rx156_eos, rx156_done
+    set rx156_off, 0
+    lt rx156_pos, 2, rx156_start
+    sub rx156_off, rx156_pos, 1
+    substr rx156_tgt, rx156_tgt, rx156_off
+  rx156_start:
+    eq $I10, 1, rx156_restart
+    rx156_cur."!cursor_debug"("START ", "quantifier:sym<**>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan159_done
+    goto rxscan159_scan
+  rxscan159_loop:
+    ($P10) = rx156_cur."from"()
+    inc $P10
+    set rx156_pos, $P10
+    ge rx156_pos, rx156_eos, rxscan159_done
+  rxscan159_scan:
+    set_addr $I10, rxscan159_loop
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxscan159_done:
 .annotate 'line', 59
   # rx subcapture "sym"
-    set_addr $I10, rxcap_168_fail
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
+    set_addr $I10, rxcap_160_fail
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
   # rx literal  "**"
-    add $I11, rx164_pos, 2
-    gt $I11, rx164_eos, rx164_fail
-    sub $I11, rx164_pos, rx164_off
-    substr $S10, rx164_tgt, $I11, 2
-    ne $S10, "**", rx164_fail
-    add rx164_pos, 2
-    set_addr $I10, rxcap_168_fail
-    ($I12, $I11) = rx164_cur."!mark_peek"($I10)
-    rx164_cur."!cursor_pos"($I11)
-    ($P10) = rx164_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx164_pos, "")
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx156_pos, 2
+    gt $I11, rx156_eos, rx156_fail
+    sub $I11, rx156_pos, rx156_off
+    substr $S10, rx156_tgt, $I11, 2
+    ne $S10, "**", rx156_fail
+    add rx156_pos, 2
+    set_addr $I10, rxcap_160_fail
+    ($I12, $I11) = rx156_cur."!mark_peek"($I10)
+    rx156_cur."!cursor_pos"($I11)
+    ($P10) = rx156_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx156_pos, "")
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_168_done
-  rxcap_168_fail:
-    goto rx164_fail
-  rxcap_168_done:
-  # rx rxquantr169 ** 0..1
-    set_addr $I170, rxquantr169_done
-    rx164_cur."!mark_push"(0, rx164_pos, $I170)
-  rxquantr169_loop:
+    goto rxcap_160_done
+  rxcap_160_fail:
+    goto rx156_fail
+  rxcap_160_done:
+  # rx rxquantr161 ** 0..1
+    set_addr $I10, rxquantr161_done
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxquantr161_loop:
   # rx subrule "normspace" subtype=capture negate=
-    rx164_cur."!cursor_pos"(rx164_pos)
-    $P10 = rx164_cur."normspace"()
-    unless $P10, rx164_fail
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."normspace"()
+    unless $P10, rx156_fail
+    goto rxsubrule162_pass
+  rxsubrule162_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx156_fail
+  rxsubrule162_pass:
+    set_addr $I10, rxsubrule162_back
+    rx156_cur."!mark_push"(0, rx156_pos, $I10, $P10)
     $P10."!cursor_names"("normspace")
-    rx164_pos = $P10."pos"()
-    (rx164_rep) = rx164_cur."!mark_commit"($I170)
-  rxquantr169_done:
+    rx156_pos = $P10."pos"()
+    set_addr $I10, rxquantr161_done
+    (rx156_rep) = rx156_cur."!mark_commit"($I10)
+  rxquantr161_done:
   # rx subrule "backmod" subtype=capture negate=
-    rx164_cur."!cursor_pos"(rx164_pos)
-    $P10 = rx164_cur."backmod"()
-    unless $P10, rx164_fail
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."backmod"()
+    unless $P10, rx156_fail
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("backmod")
-    rx164_pos = $P10."pos"()
-  # rx rxquantr171 ** 0..1
-    set_addr $I172, rxquantr171_done
-    rx164_cur."!mark_push"(0, rx164_pos, $I172)
-  rxquantr171_loop:
+    rx156_pos = $P10."pos"()
+  # rx rxquantr163 ** 0..1
+    set_addr $I10, rxquantr163_done
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxquantr163_loop:
   # rx subrule "normspace" subtype=capture negate=
-    rx164_cur."!cursor_pos"(rx164_pos)
-    $P10 = rx164_cur."normspace"()
-    unless $P10, rx164_fail
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."normspace"()
+    unless $P10, rx156_fail
+    goto rxsubrule164_pass
+  rxsubrule164_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx156_fail
+  rxsubrule164_pass:
+    set_addr $I10, rxsubrule164_back
+    rx156_cur."!mark_push"(0, rx156_pos, $I10, $P10)
     $P10."!cursor_names"("normspace")
-    rx164_pos = $P10."pos"()
-    (rx164_rep) = rx164_cur."!mark_commit"($I172)
-  rxquantr171_done:
-  alt173_0:
+    rx156_pos = $P10."pos"()
+    set_addr $I10, rxquantr163_done
+    (rx156_rep) = rx156_cur."!mark_commit"($I10)
+  rxquantr163_done:
+  alt165_0:
 .annotate 'line', 60
-    set_addr $I10, alt173_1
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
+    set_addr $I10, alt165_1
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
 .annotate 'line', 61
   # rx subcapture "min"
-    set_addr $I10, rxcap_174_fail
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
+    set_addr $I10, rxcap_166_fail
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
   # rx charclass_q d r 1..-1
-    sub $I10, rx164_pos, rx164_off
-    find_not_cclass $I11, 8, rx164_tgt, $I10, rx164_eos
+    sub $I10, rx156_pos, rx156_off
+    find_not_cclass $I11, 8, rx156_tgt, $I10, rx156_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx164_fail
-    add rx164_pos, rx164_off, $I11
-    set_addr $I10, rxcap_174_fail
-    ($I12, $I11) = rx164_cur."!mark_peek"($I10)
-    rx164_cur."!cursor_pos"($I11)
-    ($P10) = rx164_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx164_pos, "")
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx156_fail
+    add rx156_pos, rx156_off, $I11
+    set_addr $I10, rxcap_166_fail
+    ($I12, $I11) = rx156_cur."!mark_peek"($I10)
+    rx156_cur."!cursor_pos"($I11)
+    ($P10) = rx156_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx156_pos, "")
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("min")
-    goto rxcap_174_done
-  rxcap_174_fail:
-    goto rx164_fail
-  rxcap_174_done:
+    goto rxcap_166_done
+  rxcap_166_fail:
+    goto rx156_fail
+  rxcap_166_done:
 .annotate 'line', 68
-  # rx rxquantr175 ** 0..1
-    set_addr $I178, rxquantr175_done
-    rx164_cur."!mark_push"(0, rx164_pos, $I178)
-  rxquantr175_loop:
+  # rx rxquantr167 ** 0..1
+    set_addr $I10, rxquantr167_done
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  rxquantr167_loop:
 .annotate 'line', 62
   # rx literal  ".."
-    add $I11, rx164_pos, 2
-    gt $I11, rx164_eos, rx164_fail
-    sub $I11, rx164_pos, rx164_off
-    substr $S10, rx164_tgt, $I11, 2
-    ne $S10, "..", rx164_fail
-    add rx164_pos, 2
+    add $I11, rx156_pos, 2
+    gt $I11, rx156_eos, rx156_fail
+    sub $I11, rx156_pos, rx156_off
+    substr $S10, rx156_tgt, $I11, 2
+    ne $S10, "..", rx156_fail
+    add rx156_pos, 2
 .annotate 'line', 63
   # rx subcapture "max"
-    set_addr $I10, rxcap_177_fail
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
-  alt176_0:
-    set_addr $I10, alt176_1
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
+    set_addr $I10, rxcap_169_fail
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
+  alt168_0:
+    set_addr $I10, alt168_1
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
 .annotate 'line', 64
   # rx charclass_q d r 1..-1
-    sub $I10, rx164_pos, rx164_off
-    find_not_cclass $I11, 8, rx164_tgt, $I10, rx164_eos
+    sub $I10, rx156_pos, rx156_off
+    find_not_cclass $I11, 8, rx156_tgt, $I10, rx156_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx164_fail
-    add rx164_pos, rx164_off, $I11
-    goto alt176_end
-  alt176_1:
-    set_addr $I10, alt176_2
-    rx164_cur."!mark_push"(0, rx164_pos, $I10)
+    lt $I11, $I12, rx156_fail
+    add rx156_pos, rx156_off, $I11
+    goto alt168_end
+  alt168_1:
+    set_addr $I10, alt168_2
+    rx156_cur."!mark_push"(0, rx156_pos, $I10)
 .annotate 'line', 65
   # rx literal  "*"
-    add $I11, rx164_pos, 1
-    gt $I11, rx164_eos, rx164_fail
-    sub $I11, rx164_pos, rx164_off
-    substr $S10, rx164_tgt, $I11, 1
-    ne $S10, "*", rx164_fail
-    add rx164_pos, 1
-    goto alt176_end
-  alt176_2:
+    add $I11, rx156_pos, 1
+    gt $I11, rx156_eos, rx156_fail
+    sub $I11, rx156_pos, rx156_off
+    substr $S10, rx156_tgt, $I11, 1
+    ne $S10, "*", rx156_fail
+    add rx156_pos, 1
+    goto alt168_end
+  alt168_2:
 .annotate 'line', 66
   # rx subrule "panic" subtype=method negate=
-    rx164_cur."!cursor_pos"(rx164_pos)
-    $P10 = rx164_cur."panic"("Only integers or '*' allowed as range quantifier endpoint")
-    unless $P10, rx164_fail
-    rx164_pos = $P10."pos"()
-  alt176_end:
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."panic"("Only integers or '*' allowed as range quantifier endpoint")
+    unless $P10, rx156_fail
+    rx156_pos = $P10."pos"()
+  alt168_end:
 .annotate 'line', 63
-    set_addr $I10, rxcap_177_fail
-    ($I12, $I11) = rx164_cur."!mark_peek"($I10)
-    rx164_cur."!cursor_pos"($I11)
-    ($P10) = rx164_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx164_pos, "")
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    set_addr $I10, rxcap_169_fail
+    ($I12, $I11) = rx156_cur."!mark_peek"($I10)
+    rx156_cur."!cursor_pos"($I11)
+    ($P10) = rx156_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx156_pos, "")
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("max")
-    goto rxcap_177_done
-  rxcap_177_fail:
-    goto rx164_fail
-  rxcap_177_done:
+    goto rxcap_169_done
+  rxcap_169_fail:
+    goto rx156_fail
+  rxcap_169_done:
 .annotate 'line', 68
-    (rx164_rep) = rx164_cur."!mark_commit"($I178)
-  rxquantr175_done:
+    set_addr $I10, rxquantr167_done
+    (rx156_rep) = rx156_cur."!mark_commit"($I10)
+  rxquantr167_done:
 .annotate 'line', 61
-    goto alt173_end
-  alt173_1:
+    goto alt165_end
+  alt165_1:
 .annotate 'line', 69
   # rx subrule "quantified_atom" subtype=capture negate=
-    rx164_cur."!cursor_pos"(rx164_pos)
-    $P10 = rx164_cur."quantified_atom"()
-    unless $P10, rx164_fail
-    rx164_cur."!mark_push"(0, -1, 0, $P10)
+    rx156_cur."!cursor_pos"(rx156_pos)
+    $P10 = rx156_cur."quantified_atom"()
+    unless $P10, rx156_fail
+    rx156_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quantified_atom")
-    rx164_pos = $P10."pos"()
-  alt173_end:
+    rx156_pos = $P10."pos"()
+  alt165_end:
 .annotate 'line', 58
   # rx pass
-    rx164_cur."!cursor_pass"(rx164_pos, "quantifier:sym<**>")
-    rx164_cur."!cursor_debug"("PASS  ", "quantifier:sym<**>", " at pos=", rx164_pos)
-    .return (rx164_cur)
-  rx164_fail:
+    rx156_cur."!cursor_pass"(rx156_pos, "quantifier:sym<**>")
+    rx156_cur."!cursor_debug"("PASS  ", "quantifier:sym<**>", " at pos=", rx156_pos)
+    .return (rx156_cur)
+  rx156_restart:
 .annotate 'line', 3
-    (rx164_rep, rx164_pos, $I10, $P10) = rx164_cur."!mark_fail"(0)
-    lt rx164_pos, -1, rx164_done
-    eq rx164_pos, -1, rx164_fail
+    rx156_cur."!cursor_debug"("NEXT ", "quantifier:sym<**>")
+  rx156_fail:
+    (rx156_rep, rx156_pos, $I10, $P10) = rx156_cur."!mark_fail"(0)
+    lt rx156_pos, -1, rx156_done
+    eq rx156_pos, -1, rx156_fail
     jump $I10
-  rx164_done:
-    rx164_cur."!cursor_fail"()
-    rx164_cur."!cursor_debug"("FAIL  ", "quantifier:sym<**>")
-    .return (rx164_cur)
+  rx156_done:
+    rx156_cur."!cursor_fail"()
+    rx156_cur."!cursor_debug"("FAIL  ", "quantifier:sym<**>")
+    .return (rx156_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__quantifier:sym<**>"  :subid("45_1278500530.77787") :method
+.sub "!PREFIX__quantifier:sym<**>"  :subid("45_1279529218.55263") :method
 .annotate 'line', 3
-    new $P166, "ResizablePMCArray"
-    push $P166, "**"
-    .return ($P166)
+    new $P158, "ResizablePMCArray"
+    push $P158, "**"
+    .return ($P158)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backmod"  :subid("46_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backmod"  :subid("46_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .const 'Sub' $P188 = "48_1278500530.77787" 
-    capture_lex $P188
-    .local string rx180_tgt
-    .local int rx180_pos
-    .local int rx180_off
-    .local int rx180_eos
-    .local int rx180_rep
-    .local pmc rx180_cur
-    (rx180_cur, rx180_pos, rx180_tgt) = self."!cursor_start"()
-    rx180_cur."!cursor_debug"("START ", "backmod")
-    .lex unicode:"$\x{a2}", rx180_cur
+    .const 'Sub' $P178 = "48_1279529218.55263" 
+    capture_lex $P178
+    .local string rx171_tgt
+    .local int rx171_pos
+    .local int rx171_off
+    .local int rx171_eos
+    .local int rx171_rep
+    .local pmc rx171_cur
+    (rx171_cur, rx171_pos, rx171_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx171_cur
     .local pmc match
     .lex "$/", match
-    length rx180_eos, rx180_tgt
-    gt rx180_pos, rx180_eos, rx180_done
-    set rx180_off, 0
-    lt rx180_pos, 2, rx180_start
-    sub rx180_off, rx180_pos, 1
-    substr rx180_tgt, rx180_tgt, rx180_off
-  rx180_start:
+    length rx171_eos, rx171_tgt
+    gt rx171_pos, rx171_eos, rx171_done
+    set rx171_off, 0
+    lt rx171_pos, 2, rx171_start
+    sub rx171_off, rx171_pos, 1
+    substr rx171_tgt, rx171_tgt, rx171_off
+  rx171_start:
+    eq $I10, 1, rx171_restart
+    rx171_cur."!cursor_debug"("START ", "backmod")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan183_done
-    goto rxscan183_scan
-  rxscan183_loop:
-    ($P10) = rx180_cur."from"()
+    ne $I10, -1, rxscan174_done
+    goto rxscan174_scan
+  rxscan174_loop:
+    ($P10) = rx171_cur."from"()
     inc $P10
-    set rx180_pos, $P10
-    ge rx180_pos, rx180_eos, rxscan183_done
-  rxscan183_scan:
-    set_addr $I10, rxscan183_loop
-    rx180_cur."!mark_push"(0, rx180_pos, $I10)
-  rxscan183_done:
+    set rx171_pos, $P10
+    ge rx171_pos, rx171_eos, rxscan174_done
+  rxscan174_scan:
+    set_addr $I10, rxscan174_loop
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+  rxscan174_done:
 .annotate 'line', 73
-  # rx rxquantr184 ** 0..1
-    set_addr $I185, rxquantr184_done
-    rx180_cur."!mark_push"(0, rx180_pos, $I185)
-  rxquantr184_loop:
+  # rx rxquantr175 ** 0..1
+    set_addr $I10, rxquantr175_done
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
+  rxquantr175_loop:
   # rx literal  ":"
-    add $I11, rx180_pos, 1
-    gt $I11, rx180_eos, rx180_fail
-    sub $I11, rx180_pos, rx180_off
-    substr $S10, rx180_tgt, $I11, 1
-    ne $S10, ":", rx180_fail
-    add rx180_pos, 1
-    (rx180_rep) = rx180_cur."!mark_commit"($I185)
-  rxquantr184_done:
-  alt186_0:
-    set_addr $I10, alt186_1
-    rx180_cur."!mark_push"(0, rx180_pos, $I10)
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, ":", rx171_fail
+    add rx171_pos, 1
+    set_addr $I10, rxquantr175_done
+    (rx171_rep) = rx171_cur."!mark_commit"($I10)
+  rxquantr175_done:
+  alt176_0:
+    set_addr $I10, alt176_1
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
   # rx literal  "?"
-    add $I11, rx180_pos, 1
-    gt $I11, rx180_eos, rx180_fail
-    sub $I11, rx180_pos, rx180_off
-    substr $S10, rx180_tgt, $I11, 1
-    ne $S10, "?", rx180_fail
-    add rx180_pos, 1
-    goto alt186_end
-  alt186_1:
-    set_addr $I10, alt186_2
-    rx180_cur."!mark_push"(0, rx180_pos, $I10)
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "?", rx171_fail
+    add rx171_pos, 1
+    goto alt176_end
+  alt176_1:
+    set_addr $I10, alt176_2
+    rx171_cur."!mark_push"(0, rx171_pos, $I10)
   # rx literal  "!"
-    add $I11, rx180_pos, 1
-    gt $I11, rx180_eos, rx180_fail
-    sub $I11, rx180_pos, rx180_off
-    substr $S10, rx180_tgt, $I11, 1
-    ne $S10, "!", rx180_fail
-    add rx180_pos, 1
-    goto alt186_end
-  alt186_2:
+    add $I11, rx171_pos, 1
+    gt $I11, rx171_eos, rx171_fail
+    sub $I11, rx171_pos, rx171_off
+    substr $S10, rx171_tgt, $I11, 1
+    ne $S10, "!", rx171_fail
+    add rx171_pos, 1
+    goto alt176_end
+  alt176_2:
   # rx subrule "before" subtype=zerowidth negate=1
-    rx180_cur."!cursor_pos"(rx180_pos)
-    .const 'Sub' $P188 = "48_1278500530.77787" 
-    capture_lex $P188
-    $P10 = rx180_cur."before"($P188)
-    if $P10, rx180_fail
-  alt186_end:
+    rx171_cur."!cursor_pos"(rx171_pos)
+    .const 'Sub' $P178 = "48_1279529218.55263" 
+    capture_lex $P178
+    $P10 = rx171_cur."before"($P178)
+    if $P10, rx171_fail
+  alt176_end:
   # rx pass
-    rx180_cur."!cursor_pass"(rx180_pos, "backmod")
-    rx180_cur."!cursor_debug"("PASS  ", "backmod", " at pos=", rx180_pos)
-    .return (rx180_cur)
-  rx180_fail:
+    rx171_cur."!cursor_pass"(rx171_pos, "backmod")
+    rx171_cur."!cursor_debug"("PASS  ", "backmod", " at pos=", rx171_pos)
+    .return (rx171_cur)
+  rx171_restart:
 .annotate 'line', 3
-    (rx180_rep, rx180_pos, $I10, $P10) = rx180_cur."!mark_fail"(0)
-    lt rx180_pos, -1, rx180_done
-    eq rx180_pos, -1, rx180_fail
+    rx171_cur."!cursor_debug"("NEXT ", "backmod")
+  rx171_fail:
+    (rx171_rep, rx171_pos, $I10, $P10) = rx171_cur."!mark_fail"(0)
+    lt rx171_pos, -1, rx171_done
+    eq rx171_pos, -1, rx171_fail
     jump $I10
-  rx180_done:
-    rx180_cur."!cursor_fail"()
-    rx180_cur."!cursor_debug"("FAIL  ", "backmod")
-    .return (rx180_cur)
+  rx171_done:
+    rx171_cur."!cursor_fail"()
+    rx171_cur."!cursor_debug"("FAIL  ", "backmod")
+    .return (rx171_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backmod"  :subid("47_1278500530.77787") :method
+.sub "!PREFIX__backmod"  :subid("47_1279529218.55263") :method
 .annotate 'line', 3
-    new $P182, "ResizablePMCArray"
-    push $P182, ""
-    .return ($P182)
+    new $P173, "ResizablePMCArray"
+    push $P173, ""
+    .return ($P173)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block187"  :anon :subid("48_1278500530.77787") :method :outer("46_1278500530.77787")
+.sub "_block177"  :anon :subid("48_1279529218.55263") :method :outer("46_1279529218.55263")
 .annotate 'line', 73
-    .local string rx189_tgt
-    .local int rx189_pos
-    .local int rx189_off
-    .local int rx189_eos
-    .local int rx189_rep
-    .local pmc rx189_cur
-    (rx189_cur, rx189_pos, rx189_tgt) = self."!cursor_start"()
-    rx189_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx189_cur
-    .local pmc match
-    .lex "$/", match
-    length rx189_eos, rx189_tgt
-    gt rx189_pos, rx189_eos, rx189_done
-    set rx189_off, 0
-    lt rx189_pos, 2, rx189_start
-    sub rx189_off, rx189_pos, 1
-    substr rx189_tgt, rx189_tgt, rx189_off
-  rx189_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan190_done
-    goto rxscan190_scan
-  rxscan190_loop:
-    ($P10) = rx189_cur."from"()
-    inc $P10
-    set rx189_pos, $P10
-    ge rx189_pos, rx189_eos, rxscan190_done
-  rxscan190_scan:
-    set_addr $I10, rxscan190_loop
-    rx189_cur."!mark_push"(0, rx189_pos, $I10)
-  rxscan190_done:
+    .local string rx179_tgt
+    .local int rx179_pos
+    .local int rx179_off
+    .local int rx179_eos
+    .local int rx179_rep
+    .local pmc rx179_cur
+    (rx179_cur, rx179_pos, rx179_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx179_cur
+    .local pmc match
+    .lex "$/", match
+    length rx179_eos, rx179_tgt
+    gt rx179_pos, rx179_eos, rx179_done
+    set rx179_off, 0
+    lt rx179_pos, 2, rx179_start
+    sub rx179_off, rx179_pos, 1
+    substr rx179_tgt, rx179_tgt, rx179_off
+  rx179_start:
+    eq $I10, 1, rx179_restart
+    rx179_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan180_done
+    goto rxscan180_scan
+  rxscan180_loop:
+    ($P10) = rx179_cur."from"()
+    inc $P10
+    set rx179_pos, $P10
+    ge rx179_pos, rx179_eos, rxscan180_done
+  rxscan180_scan:
+    set_addr $I10, rxscan180_loop
+    rx179_cur."!mark_push"(0, rx179_pos, $I10)
+  rxscan180_done:
   # rx literal  ":"
-    add $I11, rx189_pos, 1
-    gt $I11, rx189_eos, rx189_fail
-    sub $I11, rx189_pos, rx189_off
-    substr $S10, rx189_tgt, $I11, 1
-    ne $S10, ":", rx189_fail
-    add rx189_pos, 1
+    add $I11, rx179_pos, 1
+    gt $I11, rx179_eos, rx179_fail
+    sub $I11, rx179_pos, rx179_off
+    substr $S10, rx179_tgt, $I11, 1
+    ne $S10, ":", rx179_fail
+    add rx179_pos, 1
   # rx pass
-    rx189_cur."!cursor_pass"(rx189_pos, "")
-    rx189_cur."!cursor_debug"("PASS  ", "", " at pos=", rx189_pos)
-    .return (rx189_cur)
-  rx189_fail:
-    (rx189_rep, rx189_pos, $I10, $P10) = rx189_cur."!mark_fail"(0)
-    lt rx189_pos, -1, rx189_done
-    eq rx189_pos, -1, rx189_fail
+    rx179_cur."!cursor_pass"(rx179_pos, "")
+    rx179_cur."!cursor_debug"("PASS  ", "", " at pos=", rx179_pos)
+    .return (rx179_cur)
+  rx179_restart:
+    rx179_cur."!cursor_debug"("NEXT ", "")
+  rx179_fail:
+    (rx179_rep, rx179_pos, $I10, $P10) = rx179_cur."!mark_fail"(0)
+    lt rx179_pos, -1, rx179_done
+    eq rx179_pos, -1, rx179_fail
     jump $I10
-  rx189_done:
-    rx189_cur."!cursor_fail"()
-    rx189_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx189_cur)
+  rx179_done:
+    rx179_cur."!cursor_fail"()
+    rx179_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx179_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar"  :subid("49_1278500530.77787") :method
+.sub "metachar"  :subid("49_1279529218.55263") :method
 .annotate 'line', 75
-    $P192 = self."!protoregex"("metachar")
-    .return ($P192)
+    $P182 = self."!protoregex"("metachar")
+    .return ($P182)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar"  :subid("50_1278500530.77787") :method
+.sub "!PREFIX__metachar"  :subid("50_1279529218.55263") :method
 .annotate 'line', 75
-    $P194 = self."!PREFIX__!protoregex"("metachar")
-    .return ($P194)
+    $P184 = self."!PREFIX__!protoregex"("metachar")
+    .return ($P184)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<ws>"  :subid("51_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<ws>"  :subid("51_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx196_tgt
-    .local int rx196_pos
-    .local int rx196_off
-    .local int rx196_eos
-    .local int rx196_rep
-    .local pmc rx196_cur
-    (rx196_cur, rx196_pos, rx196_tgt) = self."!cursor_start"()
-    rx196_cur."!cursor_debug"("START ", "metachar:sym<ws>")
-    .lex unicode:"$\x{a2}", rx196_cur
-    .local pmc match
-    .lex "$/", match
-    length rx196_eos, rx196_tgt
-    gt rx196_pos, rx196_eos, rx196_done
-    set rx196_off, 0
-    lt rx196_pos, 2, rx196_start
-    sub rx196_off, rx196_pos, 1
-    substr rx196_tgt, rx196_tgt, rx196_off
-  rx196_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan200_done
-    goto rxscan200_scan
-  rxscan200_loop:
-    ($P10) = rx196_cur."from"()
-    inc $P10
-    set rx196_pos, $P10
-    ge rx196_pos, rx196_eos, rxscan200_done
-  rxscan200_scan:
-    set_addr $I10, rxscan200_loop
-    rx196_cur."!mark_push"(0, rx196_pos, $I10)
-  rxscan200_done:
+    .local string rx186_tgt
+    .local int rx186_pos
+    .local int rx186_off
+    .local int rx186_eos
+    .local int rx186_rep
+    .local pmc rx186_cur
+    (rx186_cur, rx186_pos, rx186_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx186_cur
+    .local pmc match
+    .lex "$/", match
+    length rx186_eos, rx186_tgt
+    gt rx186_pos, rx186_eos, rx186_done
+    set rx186_off, 0
+    lt rx186_pos, 2, rx186_start
+    sub rx186_off, rx186_pos, 1
+    substr rx186_tgt, rx186_tgt, rx186_off
+  rx186_start:
+    eq $I10, 1, rx186_restart
+    rx186_cur."!cursor_debug"("START ", "metachar:sym<ws>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan190_done
+    goto rxscan190_scan
+  rxscan190_loop:
+    ($P10) = rx186_cur."from"()
+    inc $P10
+    set rx186_pos, $P10
+    ge rx186_pos, rx186_eos, rxscan190_done
+  rxscan190_scan:
+    set_addr $I10, rxscan190_loop
+    rx186_cur."!mark_push"(0, rx186_pos, $I10)
+  rxscan190_done:
 .annotate 'line', 76
   # rx subrule "normspace" subtype=method negate=
-    rx196_cur."!cursor_pos"(rx196_pos)
-    $P10 = rx196_cur."normspace"()
-    unless $P10, rx196_fail
-    rx196_pos = $P10."pos"()
+    rx186_cur."!cursor_pos"(rx186_pos)
+    $P10 = rx186_cur."normspace"()
+    unless $P10, rx186_fail
+    rx186_pos = $P10."pos"()
   # rx pass
-    rx196_cur."!cursor_pass"(rx196_pos, "metachar:sym<ws>")
-    rx196_cur."!cursor_debug"("PASS  ", "metachar:sym<ws>", " at pos=", rx196_pos)
-    .return (rx196_cur)
-  rx196_fail:
+    rx186_cur."!cursor_pass"(rx186_pos, "metachar:sym<ws>")
+    rx186_cur."!cursor_debug"("PASS  ", "metachar:sym<ws>", " at pos=", rx186_pos)
+    .return (rx186_cur)
+  rx186_restart:
 .annotate 'line', 3
-    (rx196_rep, rx196_pos, $I10, $P10) = rx196_cur."!mark_fail"(0)
-    lt rx196_pos, -1, rx196_done
-    eq rx196_pos, -1, rx196_fail
+    rx186_cur."!cursor_debug"("NEXT ", "metachar:sym<ws>")
+  rx186_fail:
+    (rx186_rep, rx186_pos, $I10, $P10) = rx186_cur."!mark_fail"(0)
+    lt rx186_pos, -1, rx186_done
+    eq rx186_pos, -1, rx186_fail
     jump $I10
-  rx196_done:
-    rx196_cur."!cursor_fail"()
-    rx196_cur."!cursor_debug"("FAIL  ", "metachar:sym<ws>")
-    .return (rx196_cur)
+  rx186_done:
+    rx186_cur."!cursor_fail"()
+    rx186_cur."!cursor_debug"("FAIL  ", "metachar:sym<ws>")
+    .return (rx186_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<ws>"  :subid("52_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<ws>"  :subid("52_1279529218.55263") :method
 .annotate 'line', 3
-    $P198 = self."!PREFIX__!subrule"("normspace", "")
-    new $P199, "ResizablePMCArray"
-    push $P199, $P198
-    .return ($P199)
+    $P188 = self."!PREFIX__!subrule"("normspace", "")
+    new $P189, "ResizablePMCArray"
+    push $P189, $P188
+    .return ($P189)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<[ ]>"  :subid("53_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<[ ]>"  :subid("53_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx202_tgt
-    .local int rx202_pos
-    .local int rx202_off
-    .local int rx202_eos
-    .local int rx202_rep
-    .local pmc rx202_cur
-    (rx202_cur, rx202_pos, rx202_tgt) = self."!cursor_start"()
-    rx202_cur."!cursor_debug"("START ", "metachar:sym<[ ]>")
-    .lex unicode:"$\x{a2}", rx202_cur
+    .local string rx192_tgt
+    .local int rx192_pos
+    .local int rx192_off
+    .local int rx192_eos
+    .local int rx192_rep
+    .local pmc rx192_cur
+    (rx192_cur, rx192_pos, rx192_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx192_cur
     .local pmc match
     .lex "$/", match
-    length rx202_eos, rx202_tgt
-    gt rx202_pos, rx202_eos, rx202_done
-    set rx202_off, 0
-    lt rx202_pos, 2, rx202_start
-    sub rx202_off, rx202_pos, 1
-    substr rx202_tgt, rx202_tgt, rx202_off
-  rx202_start:
+    length rx192_eos, rx192_tgt
+    gt rx192_pos, rx192_eos, rx192_done
+    set rx192_off, 0
+    lt rx192_pos, 2, rx192_start
+    sub rx192_off, rx192_pos, 1
+    substr rx192_tgt, rx192_tgt, rx192_off
+  rx192_start:
+    eq $I10, 1, rx192_restart
+    rx192_cur."!cursor_debug"("START ", "metachar:sym<[ ]>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan206_done
-    goto rxscan206_scan
-  rxscan206_loop:
-    ($P10) = rx202_cur."from"()
+    ne $I10, -1, rxscan196_done
+    goto rxscan196_scan
+  rxscan196_loop:
+    ($P10) = rx192_cur."from"()
     inc $P10
-    set rx202_pos, $P10
-    ge rx202_pos, rx202_eos, rxscan206_done
-  rxscan206_scan:
-    set_addr $I10, rxscan206_loop
-    rx202_cur."!mark_push"(0, rx202_pos, $I10)
-  rxscan206_done:
+    set rx192_pos, $P10
+    ge rx192_pos, rx192_eos, rxscan196_done
+  rxscan196_scan:
+    set_addr $I10, rxscan196_loop
+    rx192_cur."!mark_push"(0, rx192_pos, $I10)
+  rxscan196_done:
 .annotate 'line', 77
   # rx literal  "["
-    add $I11, rx202_pos, 1
-    gt $I11, rx202_eos, rx202_fail
-    sub $I11, rx202_pos, rx202_off
-    substr $S10, rx202_tgt, $I11, 1
-    ne $S10, "[", rx202_fail
-    add rx202_pos, 1
+    add $I11, rx192_pos, 1
+    gt $I11, rx192_eos, rx192_fail
+    sub $I11, rx192_pos, rx192_off
+    substr $S10, rx192_tgt, $I11, 1
+    ne $S10, "[", rx192_fail
+    add rx192_pos, 1
   # rx subrule "nibbler" subtype=capture negate=
-    rx202_cur."!cursor_pos"(rx202_pos)
-    $P10 = rx202_cur."nibbler"()
-    unless $P10, rx202_fail
-    rx202_cur."!mark_push"(0, -1, 0, $P10)
+    rx192_cur."!cursor_pos"(rx192_pos)
+    $P10 = rx192_cur."nibbler"()
+    unless $P10, rx192_fail
+    rx192_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("nibbler")
-    rx202_pos = $P10."pos"()
+    rx192_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx202_pos, 1
-    gt $I11, rx202_eos, rx202_fail
-    sub $I11, rx202_pos, rx202_off
-    substr $S10, rx202_tgt, $I11, 1
-    ne $S10, "]", rx202_fail
-    add rx202_pos, 1
+    add $I11, rx192_pos, 1
+    gt $I11, rx192_eos, rx192_fail
+    sub $I11, rx192_pos, rx192_off
+    substr $S10, rx192_tgt, $I11, 1
+    ne $S10, "]", rx192_fail
+    add rx192_pos, 1
   # rx pass
-    rx202_cur."!cursor_pass"(rx202_pos, "metachar:sym<[ ]>")
-    rx202_cur."!cursor_debug"("PASS  ", "metachar:sym<[ ]>", " at pos=", rx202_pos)
-    .return (rx202_cur)
-  rx202_fail:
+    rx192_cur."!cursor_pass"(rx192_pos, "metachar:sym<[ ]>")
+    rx192_cur."!cursor_debug"("PASS  ", "metachar:sym<[ ]>", " at pos=", rx192_pos)
+    .return (rx192_cur)
+  rx192_restart:
 .annotate 'line', 3
-    (rx202_rep, rx202_pos, $I10, $P10) = rx202_cur."!mark_fail"(0)
-    lt rx202_pos, -1, rx202_done
-    eq rx202_pos, -1, rx202_fail
+    rx192_cur."!cursor_debug"("NEXT ", "metachar:sym<[ ]>")
+  rx192_fail:
+    (rx192_rep, rx192_pos, $I10, $P10) = rx192_cur."!mark_fail"(0)
+    lt rx192_pos, -1, rx192_done
+    eq rx192_pos, -1, rx192_fail
     jump $I10
-  rx202_done:
-    rx202_cur."!cursor_fail"()
-    rx202_cur."!cursor_debug"("FAIL  ", "metachar:sym<[ ]>")
-    .return (rx202_cur)
+  rx192_done:
+    rx192_cur."!cursor_fail"()
+    rx192_cur."!cursor_debug"("FAIL  ", "metachar:sym<[ ]>")
+    .return (rx192_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<[ ]>"  :subid("54_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<[ ]>"  :subid("54_1279529218.55263") :method
 .annotate 'line', 3
-    $P204 = self."!PREFIX__!subrule"("nibbler", "[")
-    new $P205, "ResizablePMCArray"
-    push $P205, $P204
-    .return ($P205)
+    $P194 = self."!PREFIX__!subrule"("nibbler", "[")
+    new $P195, "ResizablePMCArray"
+    push $P195, $P194
+    .return ($P195)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<( )>"  :subid("55_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<( )>"  :subid("55_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx208_tgt
-    .local int rx208_pos
-    .local int rx208_off
-    .local int rx208_eos
-    .local int rx208_rep
-    .local pmc rx208_cur
-    (rx208_cur, rx208_pos, rx208_tgt) = self."!cursor_start"()
-    rx208_cur."!cursor_debug"("START ", "metachar:sym<( )>")
-    .lex unicode:"$\x{a2}", rx208_cur
+    .local string rx198_tgt
+    .local int rx198_pos
+    .local int rx198_off
+    .local int rx198_eos
+    .local int rx198_rep
+    .local pmc rx198_cur
+    (rx198_cur, rx198_pos, rx198_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx198_cur
     .local pmc match
     .lex "$/", match
-    length rx208_eos, rx208_tgt
-    gt rx208_pos, rx208_eos, rx208_done
-    set rx208_off, 0
-    lt rx208_pos, 2, rx208_start
-    sub rx208_off, rx208_pos, 1
-    substr rx208_tgt, rx208_tgt, rx208_off
-  rx208_start:
+    length rx198_eos, rx198_tgt
+    gt rx198_pos, rx198_eos, rx198_done
+    set rx198_off, 0
+    lt rx198_pos, 2, rx198_start
+    sub rx198_off, rx198_pos, 1
+    substr rx198_tgt, rx198_tgt, rx198_off
+  rx198_start:
+    eq $I10, 1, rx198_restart
+    rx198_cur."!cursor_debug"("START ", "metachar:sym<( )>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan212_done
-    goto rxscan212_scan
-  rxscan212_loop:
-    ($P10) = rx208_cur."from"()
+    ne $I10, -1, rxscan202_done
+    goto rxscan202_scan
+  rxscan202_loop:
+    ($P10) = rx198_cur."from"()
     inc $P10
-    set rx208_pos, $P10
-    ge rx208_pos, rx208_eos, rxscan212_done
-  rxscan212_scan:
-    set_addr $I10, rxscan212_loop
-    rx208_cur."!mark_push"(0, rx208_pos, $I10)
-  rxscan212_done:
+    set rx198_pos, $P10
+    ge rx198_pos, rx198_eos, rxscan202_done
+  rxscan202_scan:
+    set_addr $I10, rxscan202_loop
+    rx198_cur."!mark_push"(0, rx198_pos, $I10)
+  rxscan202_done:
 .annotate 'line', 78
   # rx literal  "("
-    add $I11, rx208_pos, 1
-    gt $I11, rx208_eos, rx208_fail
-    sub $I11, rx208_pos, rx208_off
-    substr $S10, rx208_tgt, $I11, 1
-    ne $S10, "(", rx208_fail
-    add rx208_pos, 1
+    add $I11, rx198_pos, 1
+    gt $I11, rx198_eos, rx198_fail
+    sub $I11, rx198_pos, rx198_off
+    substr $S10, rx198_tgt, $I11, 1
+    ne $S10, "(", rx198_fail
+    add rx198_pos, 1
   # rx subrule "nibbler" subtype=capture negate=
-    rx208_cur."!cursor_pos"(rx208_pos)
-    $P10 = rx208_cur."nibbler"()
-    unless $P10, rx208_fail
-    rx208_cur."!mark_push"(0, -1, 0, $P10)
+    rx198_cur."!cursor_pos"(rx198_pos)
+    $P10 = rx198_cur."nibbler"()
+    unless $P10, rx198_fail
+    rx198_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("nibbler")
-    rx208_pos = $P10."pos"()
+    rx198_pos = $P10."pos"()
   # rx literal  ")"
-    add $I11, rx208_pos, 1
-    gt $I11, rx208_eos, rx208_fail
-    sub $I11, rx208_pos, rx208_off
-    substr $S10, rx208_tgt, $I11, 1
-    ne $S10, ")", rx208_fail
-    add rx208_pos, 1
+    add $I11, rx198_pos, 1
+    gt $I11, rx198_eos, rx198_fail
+    sub $I11, rx198_pos, rx198_off
+    substr $S10, rx198_tgt, $I11, 1
+    ne $S10, ")", rx198_fail
+    add rx198_pos, 1
   # rx pass
-    rx208_cur."!cursor_pass"(rx208_pos, "metachar:sym<( )>")
-    rx208_cur."!cursor_debug"("PASS  ", "metachar:sym<( )>", " at pos=", rx208_pos)
-    .return (rx208_cur)
-  rx208_fail:
+    rx198_cur."!cursor_pass"(rx198_pos, "metachar:sym<( )>")
+    rx198_cur."!cursor_debug"("PASS  ", "metachar:sym<( )>", " at pos=", rx198_pos)
+    .return (rx198_cur)
+  rx198_restart:
 .annotate 'line', 3
-    (rx208_rep, rx208_pos, $I10, $P10) = rx208_cur."!mark_fail"(0)
-    lt rx208_pos, -1, rx208_done
-    eq rx208_pos, -1, rx208_fail
+    rx198_cur."!cursor_debug"("NEXT ", "metachar:sym<( )>")
+  rx198_fail:
+    (rx198_rep, rx198_pos, $I10, $P10) = rx198_cur."!mark_fail"(0)
+    lt rx198_pos, -1, rx198_done
+    eq rx198_pos, -1, rx198_fail
     jump $I10
-  rx208_done:
-    rx208_cur."!cursor_fail"()
-    rx208_cur."!cursor_debug"("FAIL  ", "metachar:sym<( )>")
-    .return (rx208_cur)
+  rx198_done:
+    rx198_cur."!cursor_fail"()
+    rx198_cur."!cursor_debug"("FAIL  ", "metachar:sym<( )>")
+    .return (rx198_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<( )>"  :subid("56_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<( )>"  :subid("56_1279529218.55263") :method
 .annotate 'line', 3
-    $P210 = self."!PREFIX__!subrule"("nibbler", "(")
-    new $P211, "ResizablePMCArray"
-    push $P211, $P210
-    .return ($P211)
+    $P200 = self."!PREFIX__!subrule"("nibbler", "(")
+    new $P201, "ResizablePMCArray"
+    push $P201, $P200
+    .return ($P201)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<'>"  :subid("57_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<'>"  :subid("57_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx214_tgt
-    .local int rx214_pos
-    .local int rx214_off
-    .local int rx214_eos
-    .local int rx214_rep
-    .local pmc rx214_cur
-    (rx214_cur, rx214_pos, rx214_tgt) = self."!cursor_start"()
-    rx214_cur."!cursor_debug"("START ", "metachar:sym<'>")
-    .lex unicode:"$\x{a2}", rx214_cur
+    .local string rx204_tgt
+    .local int rx204_pos
+    .local int rx204_off
+    .local int rx204_eos
+    .local int rx204_rep
+    .local pmc rx204_cur
+    (rx204_cur, rx204_pos, rx204_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx204_cur
     .local pmc match
     .lex "$/", match
-    length rx214_eos, rx214_tgt
-    gt rx214_pos, rx214_eos, rx214_done
-    set rx214_off, 0
-    lt rx214_pos, 2, rx214_start
-    sub rx214_off, rx214_pos, 1
-    substr rx214_tgt, rx214_tgt, rx214_off
-  rx214_start:
+    length rx204_eos, rx204_tgt
+    gt rx204_pos, rx204_eos, rx204_done
+    set rx204_off, 0
+    lt rx204_pos, 2, rx204_start
+    sub rx204_off, rx204_pos, 1
+    substr rx204_tgt, rx204_tgt, rx204_off
+  rx204_start:
+    eq $I10, 1, rx204_restart
+    rx204_cur."!cursor_debug"("START ", "metachar:sym<'>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan217_done
-    goto rxscan217_scan
-  rxscan217_loop:
-    ($P10) = rx214_cur."from"()
+    ne $I10, -1, rxscan207_done
+    goto rxscan207_scan
+  rxscan207_loop:
+    ($P10) = rx204_cur."from"()
     inc $P10
-    set rx214_pos, $P10
-    ge rx214_pos, rx214_eos, rxscan217_done
-  rxscan217_scan:
-    set_addr $I10, rxscan217_loop
-    rx214_cur."!mark_push"(0, rx214_pos, $I10)
-  rxscan217_done:
+    set rx204_pos, $P10
+    ge rx204_pos, rx204_eos, rxscan207_done
+  rxscan207_scan:
+    set_addr $I10, rxscan207_loop
+    rx204_cur."!mark_push"(0, rx204_pos, $I10)
+  rxscan207_done:
 .annotate 'line', 79
   # rx enumcharlist negate=0 zerowidth
-    ge rx214_pos, rx214_eos, rx214_fail
-    sub $I10, rx214_pos, rx214_off
-    substr $S10, rx214_tgt, $I10, 1
+    ge rx204_pos, rx204_eos, rx204_fail
+    sub $I10, rx204_pos, rx204_off
+    substr $S10, rx204_tgt, $I10, 1
     index $I11, "'", $S10
-    lt $I11, 0, rx214_fail
+    lt $I11, 0, rx204_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx214_cur."!cursor_pos"(rx214_pos)
-    $P10 = rx214_cur."quote_EXPR"(":q")
-    unless $P10, rx214_fail
-    rx214_cur."!mark_push"(0, -1, 0, $P10)
+    rx204_cur."!cursor_pos"(rx204_pos)
+    $P10 = rx204_cur."quote_EXPR"(":q")
+    unless $P10, rx204_fail
+    rx204_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx214_pos = $P10."pos"()
+    rx204_pos = $P10."pos"()
   # rx pass
-    rx214_cur."!cursor_pass"(rx214_pos, "metachar:sym<'>")
-    rx214_cur."!cursor_debug"("PASS  ", "metachar:sym<'>", " at pos=", rx214_pos)
-    .return (rx214_cur)
-  rx214_fail:
+    rx204_cur."!cursor_pass"(rx204_pos, "metachar:sym<'>")
+    rx204_cur."!cursor_debug"("PASS  ", "metachar:sym<'>", " at pos=", rx204_pos)
+    .return (rx204_cur)
+  rx204_restart:
 .annotate 'line', 3
-    (rx214_rep, rx214_pos, $I10, $P10) = rx214_cur."!mark_fail"(0)
-    lt rx214_pos, -1, rx214_done
-    eq rx214_pos, -1, rx214_fail
+    rx204_cur."!cursor_debug"("NEXT ", "metachar:sym<'>")
+  rx204_fail:
+    (rx204_rep, rx204_pos, $I10, $P10) = rx204_cur."!mark_fail"(0)
+    lt rx204_pos, -1, rx204_done
+    eq rx204_pos, -1, rx204_fail
     jump $I10
-  rx214_done:
-    rx214_cur."!cursor_fail"()
-    rx214_cur."!cursor_debug"("FAIL  ", "metachar:sym<'>")
-    .return (rx214_cur)
+  rx204_done:
+    rx204_cur."!cursor_fail"()
+    rx204_cur."!cursor_debug"("FAIL  ", "metachar:sym<'>")
+    .return (rx204_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<'>"  :subid("58_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<'>"  :subid("58_1279529218.55263") :method
 .annotate 'line', 3
-    new $P216, "ResizablePMCArray"
-    push $P216, "'"
-    .return ($P216)
+    new $P206, "ResizablePMCArray"
+    push $P206, "'"
+    .return ($P206)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<\">"  :subid("59_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<\">"  :subid("59_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx219_tgt
-    .local int rx219_pos
-    .local int rx219_off
-    .local int rx219_eos
-    .local int rx219_rep
-    .local pmc rx219_cur
-    (rx219_cur, rx219_pos, rx219_tgt) = self."!cursor_start"()
-    rx219_cur."!cursor_debug"("START ", "metachar:sym<\">")
-    .lex unicode:"$\x{a2}", rx219_cur
-    .local pmc match
-    .lex "$/", match
-    length rx219_eos, rx219_tgt
-    gt rx219_pos, rx219_eos, rx219_done
-    set rx219_off, 0
-    lt rx219_pos, 2, rx219_start
-    sub rx219_off, rx219_pos, 1
-    substr rx219_tgt, rx219_tgt, rx219_off
-  rx219_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan222_done
-    goto rxscan222_scan
-  rxscan222_loop:
-    ($P10) = rx219_cur."from"()
-    inc $P10
-    set rx219_pos, $P10
-    ge rx219_pos, rx219_eos, rxscan222_done
-  rxscan222_scan:
-    set_addr $I10, rxscan222_loop
-    rx219_cur."!mark_push"(0, rx219_pos, $I10)
-  rxscan222_done:
+    .local string rx209_tgt
+    .local int rx209_pos
+    .local int rx209_off
+    .local int rx209_eos
+    .local int rx209_rep
+    .local pmc rx209_cur
+    (rx209_cur, rx209_pos, rx209_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx209_cur
+    .local pmc match
+    .lex "$/", match
+    length rx209_eos, rx209_tgt
+    gt rx209_pos, rx209_eos, rx209_done
+    set rx209_off, 0
+    lt rx209_pos, 2, rx209_start
+    sub rx209_off, rx209_pos, 1
+    substr rx209_tgt, rx209_tgt, rx209_off
+  rx209_start:
+    eq $I10, 1, rx209_restart
+    rx209_cur."!cursor_debug"("START ", "metachar:sym<\">")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan212_done
+    goto rxscan212_scan
+  rxscan212_loop:
+    ($P10) = rx209_cur."from"()
+    inc $P10
+    set rx209_pos, $P10
+    ge rx209_pos, rx209_eos, rxscan212_done
+  rxscan212_scan:
+    set_addr $I10, rxscan212_loop
+    rx209_cur."!mark_push"(0, rx209_pos, $I10)
+  rxscan212_done:
 .annotate 'line', 80
   # rx enumcharlist negate=0 zerowidth
-    ge rx219_pos, rx219_eos, rx219_fail
-    sub $I10, rx219_pos, rx219_off
-    substr $S10, rx219_tgt, $I10, 1
+    ge rx209_pos, rx209_eos, rx209_fail
+    sub $I10, rx209_pos, rx209_off
+    substr $S10, rx209_tgt, $I10, 1
     index $I11, "\"", $S10
-    lt $I11, 0, rx219_fail
+    lt $I11, 0, rx209_fail
   # rx subrule "quote_EXPR" subtype=capture negate=
-    rx219_cur."!cursor_pos"(rx219_pos)
-    $P10 = rx219_cur."quote_EXPR"(":qq")
-    unless $P10, rx219_fail
-    rx219_cur."!mark_push"(0, -1, 0, $P10)
+    rx209_cur."!cursor_pos"(rx209_pos)
+    $P10 = rx209_cur."quote_EXPR"(":qq")
+    unless $P10, rx209_fail
+    rx209_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quote_EXPR")
-    rx219_pos = $P10."pos"()
+    rx209_pos = $P10."pos"()
   # rx pass
-    rx219_cur."!cursor_pass"(rx219_pos, "metachar:sym<\">")
-    rx219_cur."!cursor_debug"("PASS  ", "metachar:sym<\">", " at pos=", rx219_pos)
-    .return (rx219_cur)
-  rx219_fail:
+    rx209_cur."!cursor_pass"(rx209_pos, "metachar:sym<\">")
+    rx209_cur."!cursor_debug"("PASS  ", "metachar:sym<\">", " at pos=", rx209_pos)
+    .return (rx209_cur)
+  rx209_restart:
 .annotate 'line', 3
-    (rx219_rep, rx219_pos, $I10, $P10) = rx219_cur."!mark_fail"(0)
-    lt rx219_pos, -1, rx219_done
-    eq rx219_pos, -1, rx219_fail
+    rx209_cur."!cursor_debug"("NEXT ", "metachar:sym<\">")
+  rx209_fail:
+    (rx209_rep, rx209_pos, $I10, $P10) = rx209_cur."!mark_fail"(0)
+    lt rx209_pos, -1, rx209_done
+    eq rx209_pos, -1, rx209_fail
     jump $I10
-  rx219_done:
-    rx219_cur."!cursor_fail"()
-    rx219_cur."!cursor_debug"("FAIL  ", "metachar:sym<\">")
-    .return (rx219_cur)
+  rx209_done:
+    rx209_cur."!cursor_fail"()
+    rx209_cur."!cursor_debug"("FAIL  ", "metachar:sym<\">")
+    .return (rx209_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<\">"  :subid("60_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<\">"  :subid("60_1279529218.55263") :method
 .annotate 'line', 3
-    new $P221, "ResizablePMCArray"
-    push $P221, "\""
-    .return ($P221)
+    new $P211, "ResizablePMCArray"
+    push $P211, "\""
+    .return ($P211)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<.>"  :subid("61_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<.>"  :subid("61_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx224_tgt
-    .local int rx224_pos
-    .local int rx224_off
-    .local int rx224_eos
-    .local int rx224_rep
-    .local pmc rx224_cur
-    (rx224_cur, rx224_pos, rx224_tgt) = self."!cursor_start"()
-    rx224_cur."!cursor_debug"("START ", "metachar:sym<.>")
-    .lex unicode:"$\x{a2}", rx224_cur
+    .local string rx214_tgt
+    .local int rx214_pos
+    .local int rx214_off
+    .local int rx214_eos
+    .local int rx214_rep
+    .local pmc rx214_cur
+    (rx214_cur, rx214_pos, rx214_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx214_cur
     .local pmc match
     .lex "$/", match
-    length rx224_eos, rx224_tgt
-    gt rx224_pos, rx224_eos, rx224_done
-    set rx224_off, 0
-    lt rx224_pos, 2, rx224_start
-    sub rx224_off, rx224_pos, 1
-    substr rx224_tgt, rx224_tgt, rx224_off
-  rx224_start:
+    length rx214_eos, rx214_tgt
+    gt rx214_pos, rx214_eos, rx214_done
+    set rx214_off, 0
+    lt rx214_pos, 2, rx214_start
+    sub rx214_off, rx214_pos, 1
+    substr rx214_tgt, rx214_tgt, rx214_off
+  rx214_start:
+    eq $I10, 1, rx214_restart
+    rx214_cur."!cursor_debug"("START ", "metachar:sym<.>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan227_done
-    goto rxscan227_scan
-  rxscan227_loop:
-    ($P10) = rx224_cur."from"()
+    ne $I10, -1, rxscan217_done
+    goto rxscan217_scan
+  rxscan217_loop:
+    ($P10) = rx214_cur."from"()
     inc $P10
-    set rx224_pos, $P10
-    ge rx224_pos, rx224_eos, rxscan227_done
-  rxscan227_scan:
-    set_addr $I10, rxscan227_loop
-    rx224_cur."!mark_push"(0, rx224_pos, $I10)
-  rxscan227_done:
+    set rx214_pos, $P10
+    ge rx214_pos, rx214_eos, rxscan217_done
+  rxscan217_scan:
+    set_addr $I10, rxscan217_loop
+    rx214_cur."!mark_push"(0, rx214_pos, $I10)
+  rxscan217_done:
 .annotate 'line', 81
   # rx subcapture "sym"
-    set_addr $I10, rxcap_228_fail
-    rx224_cur."!mark_push"(0, rx224_pos, $I10)
+    set_addr $I10, rxcap_218_fail
+    rx214_cur."!mark_push"(0, rx214_pos, $I10)
   # rx literal  "."
-    add $I11, rx224_pos, 1
-    gt $I11, rx224_eos, rx224_fail
-    sub $I11, rx224_pos, rx224_off
-    substr $S10, rx224_tgt, $I11, 1
-    ne $S10, ".", rx224_fail
-    add rx224_pos, 1
-    set_addr $I10, rxcap_228_fail
-    ($I12, $I11) = rx224_cur."!mark_peek"($I10)
-    rx224_cur."!cursor_pos"($I11)
-    ($P10) = rx224_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx224_pos, "")
-    rx224_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx214_pos, 1
+    gt $I11, rx214_eos, rx214_fail
+    sub $I11, rx214_pos, rx214_off
+    substr $S10, rx214_tgt, $I11, 1
+    ne $S10, ".", rx214_fail
+    add rx214_pos, 1
+    set_addr $I10, rxcap_218_fail
+    ($I12, $I11) = rx214_cur."!mark_peek"($I10)
+    rx214_cur."!cursor_pos"($I11)
+    ($P10) = rx214_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx214_pos, "")
+    rx214_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_228_done
-  rxcap_228_fail:
-    goto rx224_fail
-  rxcap_228_done:
+    goto rxcap_218_done
+  rxcap_218_fail:
+    goto rx214_fail
+  rxcap_218_done:
   # rx pass
-    rx224_cur."!cursor_pass"(rx224_pos, "metachar:sym<.>")
-    rx224_cur."!cursor_debug"("PASS  ", "metachar:sym<.>", " at pos=", rx224_pos)
-    .return (rx224_cur)
-  rx224_fail:
+    rx214_cur."!cursor_pass"(rx214_pos, "metachar:sym<.>")
+    rx214_cur."!cursor_debug"("PASS  ", "metachar:sym<.>", " at pos=", rx214_pos)
+    .return (rx214_cur)
+  rx214_restart:
 .annotate 'line', 3
-    (rx224_rep, rx224_pos, $I10, $P10) = rx224_cur."!mark_fail"(0)
-    lt rx224_pos, -1, rx224_done
-    eq rx224_pos, -1, rx224_fail
+    rx214_cur."!cursor_debug"("NEXT ", "metachar:sym<.>")
+  rx214_fail:
+    (rx214_rep, rx214_pos, $I10, $P10) = rx214_cur."!mark_fail"(0)
+    lt rx214_pos, -1, rx214_done
+    eq rx214_pos, -1, rx214_fail
     jump $I10
-  rx224_done:
-    rx224_cur."!cursor_fail"()
-    rx224_cur."!cursor_debug"("FAIL  ", "metachar:sym<.>")
-    .return (rx224_cur)
+  rx214_done:
+    rx214_cur."!cursor_fail"()
+    rx214_cur."!cursor_debug"("FAIL  ", "metachar:sym<.>")
+    .return (rx214_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<.>"  :subid("62_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<.>"  :subid("62_1279529218.55263") :method
 .annotate 'line', 3
-    new $P226, "ResizablePMCArray"
-    push $P226, "."
-    .return ($P226)
+    new $P216, "ResizablePMCArray"
+    push $P216, "."
+    .return ($P216)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<^>"  :subid("63_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<^>"  :subid("63_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx230_tgt
-    .local int rx230_pos
-    .local int rx230_off
-    .local int rx230_eos
-    .local int rx230_rep
-    .local pmc rx230_cur
-    (rx230_cur, rx230_pos, rx230_tgt) = self."!cursor_start"()
-    rx230_cur."!cursor_debug"("START ", "metachar:sym<^>")
-    .lex unicode:"$\x{a2}", rx230_cur
-    .local pmc match
-    .lex "$/", match
-    length rx230_eos, rx230_tgt
-    gt rx230_pos, rx230_eos, rx230_done
-    set rx230_off, 0
-    lt rx230_pos, 2, rx230_start
-    sub rx230_off, rx230_pos, 1
-    substr rx230_tgt, rx230_tgt, rx230_off
-  rx230_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan233_done
-    goto rxscan233_scan
-  rxscan233_loop:
-    ($P10) = rx230_cur."from"()
-    inc $P10
-    set rx230_pos, $P10
-    ge rx230_pos, rx230_eos, rxscan233_done
-  rxscan233_scan:
-    set_addr $I10, rxscan233_loop
-    rx230_cur."!mark_push"(0, rx230_pos, $I10)
-  rxscan233_done:
+    .local string rx220_tgt
+    .local int rx220_pos
+    .local int rx220_off
+    .local int rx220_eos
+    .local int rx220_rep
+    .local pmc rx220_cur
+    (rx220_cur, rx220_pos, rx220_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx220_cur
+    .local pmc match
+    .lex "$/", match
+    length rx220_eos, rx220_tgt
+    gt rx220_pos, rx220_eos, rx220_done
+    set rx220_off, 0
+    lt rx220_pos, 2, rx220_start
+    sub rx220_off, rx220_pos, 1
+    substr rx220_tgt, rx220_tgt, rx220_off
+  rx220_start:
+    eq $I10, 1, rx220_restart
+    rx220_cur."!cursor_debug"("START ", "metachar:sym<^>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan223_done
+    goto rxscan223_scan
+  rxscan223_loop:
+    ($P10) = rx220_cur."from"()
+    inc $P10
+    set rx220_pos, $P10
+    ge rx220_pos, rx220_eos, rxscan223_done
+  rxscan223_scan:
+    set_addr $I10, rxscan223_loop
+    rx220_cur."!mark_push"(0, rx220_pos, $I10)
+  rxscan223_done:
 .annotate 'line', 82
   # rx subcapture "sym"
-    set_addr $I10, rxcap_234_fail
-    rx230_cur."!mark_push"(0, rx230_pos, $I10)
+    set_addr $I10, rxcap_224_fail
+    rx220_cur."!mark_push"(0, rx220_pos, $I10)
   # rx literal  "^"
-    add $I11, rx230_pos, 1
-    gt $I11, rx230_eos, rx230_fail
-    sub $I11, rx230_pos, rx230_off
-    substr $S10, rx230_tgt, $I11, 1
-    ne $S10, "^", rx230_fail
-    add rx230_pos, 1
-    set_addr $I10, rxcap_234_fail
-    ($I12, $I11) = rx230_cur."!mark_peek"($I10)
-    rx230_cur."!cursor_pos"($I11)
-    ($P10) = rx230_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx230_pos, "")
-    rx230_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx220_pos, 1
+    gt $I11, rx220_eos, rx220_fail
+    sub $I11, rx220_pos, rx220_off
+    substr $S10, rx220_tgt, $I11, 1
+    ne $S10, "^", rx220_fail
+    add rx220_pos, 1
+    set_addr $I10, rxcap_224_fail
+    ($I12, $I11) = rx220_cur."!mark_peek"($I10)
+    rx220_cur."!cursor_pos"($I11)
+    ($P10) = rx220_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx220_pos, "")
+    rx220_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_234_done
-  rxcap_234_fail:
-    goto rx230_fail
-  rxcap_234_done:
+    goto rxcap_224_done
+  rxcap_224_fail:
+    goto rx220_fail
+  rxcap_224_done:
   # rx pass
-    rx230_cur."!cursor_pass"(rx230_pos, "metachar:sym<^>")
-    rx230_cur."!cursor_debug"("PASS  ", "metachar:sym<^>", " at pos=", rx230_pos)
-    .return (rx230_cur)
-  rx230_fail:
+    rx220_cur."!cursor_pass"(rx220_pos, "metachar:sym<^>")
+    rx220_cur."!cursor_debug"("PASS  ", "metachar:sym<^>", " at pos=", rx220_pos)
+    .return (rx220_cur)
+  rx220_restart:
 .annotate 'line', 3
-    (rx230_rep, rx230_pos, $I10, $P10) = rx230_cur."!mark_fail"(0)
-    lt rx230_pos, -1, rx230_done
-    eq rx230_pos, -1, rx230_fail
+    rx220_cur."!cursor_debug"("NEXT ", "metachar:sym<^>")
+  rx220_fail:
+    (rx220_rep, rx220_pos, $I10, $P10) = rx220_cur."!mark_fail"(0)
+    lt rx220_pos, -1, rx220_done
+    eq rx220_pos, -1, rx220_fail
     jump $I10
-  rx230_done:
-    rx230_cur."!cursor_fail"()
-    rx230_cur."!cursor_debug"("FAIL  ", "metachar:sym<^>")
-    .return (rx230_cur)
+  rx220_done:
+    rx220_cur."!cursor_fail"()
+    rx220_cur."!cursor_debug"("FAIL  ", "metachar:sym<^>")
+    .return (rx220_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<^>"  :subid("64_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<^>"  :subid("64_1279529218.55263") :method
 .annotate 'line', 3
-    new $P232, "ResizablePMCArray"
-    push $P232, "^"
-    .return ($P232)
+    new $P222, "ResizablePMCArray"
+    push $P222, "^"
+    .return ($P222)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<^^>"  :subid("65_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<^^>"  :subid("65_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx236_tgt
-    .local int rx236_pos
-    .local int rx236_off
-    .local int rx236_eos
-    .local int rx236_rep
-    .local pmc rx236_cur
-    (rx236_cur, rx236_pos, rx236_tgt) = self."!cursor_start"()
-    rx236_cur."!cursor_debug"("START ", "metachar:sym<^^>")
-    .lex unicode:"$\x{a2}", rx236_cur
+    .local string rx226_tgt
+    .local int rx226_pos
+    .local int rx226_off
+    .local int rx226_eos
+    .local int rx226_rep
+    .local pmc rx226_cur
+    (rx226_cur, rx226_pos, rx226_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx226_cur
     .local pmc match
     .lex "$/", match
-    length rx236_eos, rx236_tgt
-    gt rx236_pos, rx236_eos, rx236_done
-    set rx236_off, 0
-    lt rx236_pos, 2, rx236_start
-    sub rx236_off, rx236_pos, 1
-    substr rx236_tgt, rx236_tgt, rx236_off
-  rx236_start:
+    length rx226_eos, rx226_tgt
+    gt rx226_pos, rx226_eos, rx226_done
+    set rx226_off, 0
+    lt rx226_pos, 2, rx226_start
+    sub rx226_off, rx226_pos, 1
+    substr rx226_tgt, rx226_tgt, rx226_off
+  rx226_start:
+    eq $I10, 1, rx226_restart
+    rx226_cur."!cursor_debug"("START ", "metachar:sym<^^>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan239_done
-    goto rxscan239_scan
-  rxscan239_loop:
-    ($P10) = rx236_cur."from"()
+    ne $I10, -1, rxscan229_done
+    goto rxscan229_scan
+  rxscan229_loop:
+    ($P10) = rx226_cur."from"()
     inc $P10
-    set rx236_pos, $P10
-    ge rx236_pos, rx236_eos, rxscan239_done
-  rxscan239_scan:
-    set_addr $I10, rxscan239_loop
-    rx236_cur."!mark_push"(0, rx236_pos, $I10)
-  rxscan239_done:
+    set rx226_pos, $P10
+    ge rx226_pos, rx226_eos, rxscan229_done
+  rxscan229_scan:
+    set_addr $I10, rxscan229_loop
+    rx226_cur."!mark_push"(0, rx226_pos, $I10)
+  rxscan229_done:
 .annotate 'line', 83
   # rx subcapture "sym"
-    set_addr $I10, rxcap_240_fail
-    rx236_cur."!mark_push"(0, rx236_pos, $I10)
+    set_addr $I10, rxcap_230_fail
+    rx226_cur."!mark_push"(0, rx226_pos, $I10)
   # rx literal  "^^"
-    add $I11, rx236_pos, 2
-    gt $I11, rx236_eos, rx236_fail
-    sub $I11, rx236_pos, rx236_off
-    substr $S10, rx236_tgt, $I11, 2
-    ne $S10, "^^", rx236_fail
-    add rx236_pos, 2
-    set_addr $I10, rxcap_240_fail
-    ($I12, $I11) = rx236_cur."!mark_peek"($I10)
-    rx236_cur."!cursor_pos"($I11)
-    ($P10) = rx236_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx236_pos, "")
-    rx236_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx226_pos, 2
+    gt $I11, rx226_eos, rx226_fail
+    sub $I11, rx226_pos, rx226_off
+    substr $S10, rx226_tgt, $I11, 2
+    ne $S10, "^^", rx226_fail
+    add rx226_pos, 2
+    set_addr $I10, rxcap_230_fail
+    ($I12, $I11) = rx226_cur."!mark_peek"($I10)
+    rx226_cur."!cursor_pos"($I11)
+    ($P10) = rx226_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx226_pos, "")
+    rx226_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_240_done
-  rxcap_240_fail:
-    goto rx236_fail
-  rxcap_240_done:
+    goto rxcap_230_done
+  rxcap_230_fail:
+    goto rx226_fail
+  rxcap_230_done:
   # rx pass
-    rx236_cur."!cursor_pass"(rx236_pos, "metachar:sym<^^>")
-    rx236_cur."!cursor_debug"("PASS  ", "metachar:sym<^^>", " at pos=", rx236_pos)
-    .return (rx236_cur)
-  rx236_fail:
+    rx226_cur."!cursor_pass"(rx226_pos, "metachar:sym<^^>")
+    rx226_cur."!cursor_debug"("PASS  ", "metachar:sym<^^>", " at pos=", rx226_pos)
+    .return (rx226_cur)
+  rx226_restart:
 .annotate 'line', 3
-    (rx236_rep, rx236_pos, $I10, $P10) = rx236_cur."!mark_fail"(0)
-    lt rx236_pos, -1, rx236_done
-    eq rx236_pos, -1, rx236_fail
+    rx226_cur."!cursor_debug"("NEXT ", "metachar:sym<^^>")
+  rx226_fail:
+    (rx226_rep, rx226_pos, $I10, $P10) = rx226_cur."!mark_fail"(0)
+    lt rx226_pos, -1, rx226_done
+    eq rx226_pos, -1, rx226_fail
     jump $I10
-  rx236_done:
-    rx236_cur."!cursor_fail"()
-    rx236_cur."!cursor_debug"("FAIL  ", "metachar:sym<^^>")
-    .return (rx236_cur)
+  rx226_done:
+    rx226_cur."!cursor_fail"()
+    rx226_cur."!cursor_debug"("FAIL  ", "metachar:sym<^^>")
+    .return (rx226_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<^^>"  :subid("66_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<^^>"  :subid("66_1279529218.55263") :method
 .annotate 'line', 3
-    new $P238, "ResizablePMCArray"
-    push $P238, "^^"
-    .return ($P238)
+    new $P228, "ResizablePMCArray"
+    push $P228, "^^"
+    .return ($P228)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<$>"  :subid("67_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<$>"  :subid("67_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx242_tgt
-    .local int rx242_pos
-    .local int rx242_off
-    .local int rx242_eos
-    .local int rx242_rep
-    .local pmc rx242_cur
-    (rx242_cur, rx242_pos, rx242_tgt) = self."!cursor_start"()
-    rx242_cur."!cursor_debug"("START ", "metachar:sym<$>")
-    .lex unicode:"$\x{a2}", rx242_cur
+    .local string rx232_tgt
+    .local int rx232_pos
+    .local int rx232_off
+    .local int rx232_eos
+    .local int rx232_rep
+    .local pmc rx232_cur
+    (rx232_cur, rx232_pos, rx232_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx232_cur
     .local pmc match
     .lex "$/", match
-    length rx242_eos, rx242_tgt
-    gt rx242_pos, rx242_eos, rx242_done
-    set rx242_off, 0
-    lt rx242_pos, 2, rx242_start
-    sub rx242_off, rx242_pos, 1
-    substr rx242_tgt, rx242_tgt, rx242_off
-  rx242_start:
+    length rx232_eos, rx232_tgt
+    gt rx232_pos, rx232_eos, rx232_done
+    set rx232_off, 0
+    lt rx232_pos, 2, rx232_start
+    sub rx232_off, rx232_pos, 1
+    substr rx232_tgt, rx232_tgt, rx232_off
+  rx232_start:
+    eq $I10, 1, rx232_restart
+    rx232_cur."!cursor_debug"("START ", "metachar:sym<$>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan245_done
-    goto rxscan245_scan
-  rxscan245_loop:
-    ($P10) = rx242_cur."from"()
+    ne $I10, -1, rxscan235_done
+    goto rxscan235_scan
+  rxscan235_loop:
+    ($P10) = rx232_cur."from"()
     inc $P10
-    set rx242_pos, $P10
-    ge rx242_pos, rx242_eos, rxscan245_done
-  rxscan245_scan:
-    set_addr $I10, rxscan245_loop
-    rx242_cur."!mark_push"(0, rx242_pos, $I10)
-  rxscan245_done:
+    set rx232_pos, $P10
+    ge rx232_pos, rx232_eos, rxscan235_done
+  rxscan235_scan:
+    set_addr $I10, rxscan235_loop
+    rx232_cur."!mark_push"(0, rx232_pos, $I10)
+  rxscan235_done:
 .annotate 'line', 84
   # rx subcapture "sym"
-    set_addr $I10, rxcap_246_fail
-    rx242_cur."!mark_push"(0, rx242_pos, $I10)
+    set_addr $I10, rxcap_236_fail
+    rx232_cur."!mark_push"(0, rx232_pos, $I10)
   # rx literal  "$"
-    add $I11, rx242_pos, 1
-    gt $I11, rx242_eos, rx242_fail
-    sub $I11, rx242_pos, rx242_off
-    substr $S10, rx242_tgt, $I11, 1
-    ne $S10, "$", rx242_fail
-    add rx242_pos, 1
-    set_addr $I10, rxcap_246_fail
-    ($I12, $I11) = rx242_cur."!mark_peek"($I10)
-    rx242_cur."!cursor_pos"($I11)
-    ($P10) = rx242_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx242_pos, "")
-    rx242_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx232_pos, 1
+    gt $I11, rx232_eos, rx232_fail
+    sub $I11, rx232_pos, rx232_off
+    substr $S10, rx232_tgt, $I11, 1
+    ne $S10, "$", rx232_fail
+    add rx232_pos, 1
+    set_addr $I10, rxcap_236_fail
+    ($I12, $I11) = rx232_cur."!mark_peek"($I10)
+    rx232_cur."!cursor_pos"($I11)
+    ($P10) = rx232_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx232_pos, "")
+    rx232_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_246_done
-  rxcap_246_fail:
-    goto rx242_fail
-  rxcap_246_done:
+    goto rxcap_236_done
+  rxcap_236_fail:
+    goto rx232_fail
+  rxcap_236_done:
   # rx pass
-    rx242_cur."!cursor_pass"(rx242_pos, "metachar:sym<$>")
-    rx242_cur."!cursor_debug"("PASS  ", "metachar:sym<$>", " at pos=", rx242_pos)
-    .return (rx242_cur)
-  rx242_fail:
+    rx232_cur."!cursor_pass"(rx232_pos, "metachar:sym<$>")
+    rx232_cur."!cursor_debug"("PASS  ", "metachar:sym<$>", " at pos=", rx232_pos)
+    .return (rx232_cur)
+  rx232_restart:
 .annotate 'line', 3
-    (rx242_rep, rx242_pos, $I10, $P10) = rx242_cur."!mark_fail"(0)
-    lt rx242_pos, -1, rx242_done
-    eq rx242_pos, -1, rx242_fail
+    rx232_cur."!cursor_debug"("NEXT ", "metachar:sym<$>")
+  rx232_fail:
+    (rx232_rep, rx232_pos, $I10, $P10) = rx232_cur."!mark_fail"(0)
+    lt rx232_pos, -1, rx232_done
+    eq rx232_pos, -1, rx232_fail
     jump $I10
-  rx242_done:
-    rx242_cur."!cursor_fail"()
-    rx242_cur."!cursor_debug"("FAIL  ", "metachar:sym<$>")
-    .return (rx242_cur)
+  rx232_done:
+    rx232_cur."!cursor_fail"()
+    rx232_cur."!cursor_debug"("FAIL  ", "metachar:sym<$>")
+    .return (rx232_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<$>"  :subid("68_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<$>"  :subid("68_1279529218.55263") :method
 .annotate 'line', 3
-    new $P244, "ResizablePMCArray"
-    push $P244, "$"
-    .return ($P244)
+    new $P234, "ResizablePMCArray"
+    push $P234, "$"
+    .return ($P234)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<$$>"  :subid("69_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<$$>"  :subid("69_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx248_tgt
-    .local int rx248_pos
-    .local int rx248_off
-    .local int rx248_eos
-    .local int rx248_rep
-    .local pmc rx248_cur
-    (rx248_cur, rx248_pos, rx248_tgt) = self."!cursor_start"()
-    rx248_cur."!cursor_debug"("START ", "metachar:sym<$$>")
-    .lex unicode:"$\x{a2}", rx248_cur
+    .local string rx238_tgt
+    .local int rx238_pos
+    .local int rx238_off
+    .local int rx238_eos
+    .local int rx238_rep
+    .local pmc rx238_cur
+    (rx238_cur, rx238_pos, rx238_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx238_cur
     .local pmc match
     .lex "$/", match
-    length rx248_eos, rx248_tgt
-    gt rx248_pos, rx248_eos, rx248_done
-    set rx248_off, 0
-    lt rx248_pos, 2, rx248_start
-    sub rx248_off, rx248_pos, 1
-    substr rx248_tgt, rx248_tgt, rx248_off
-  rx248_start:
+    length rx238_eos, rx238_tgt
+    gt rx238_pos, rx238_eos, rx238_done
+    set rx238_off, 0
+    lt rx238_pos, 2, rx238_start
+    sub rx238_off, rx238_pos, 1
+    substr rx238_tgt, rx238_tgt, rx238_off
+  rx238_start:
+    eq $I10, 1, rx238_restart
+    rx238_cur."!cursor_debug"("START ", "metachar:sym<$$>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan251_done
-    goto rxscan251_scan
-  rxscan251_loop:
-    ($P10) = rx248_cur."from"()
+    ne $I10, -1, rxscan241_done
+    goto rxscan241_scan
+  rxscan241_loop:
+    ($P10) = rx238_cur."from"()
     inc $P10
-    set rx248_pos, $P10
-    ge rx248_pos, rx248_eos, rxscan251_done
-  rxscan251_scan:
-    set_addr $I10, rxscan251_loop
-    rx248_cur."!mark_push"(0, rx248_pos, $I10)
-  rxscan251_done:
+    set rx238_pos, $P10
+    ge rx238_pos, rx238_eos, rxscan241_done
+  rxscan241_scan:
+    set_addr $I10, rxscan241_loop
+    rx238_cur."!mark_push"(0, rx238_pos, $I10)
+  rxscan241_done:
 .annotate 'line', 85
   # rx subcapture "sym"
-    set_addr $I10, rxcap_252_fail
-    rx248_cur."!mark_push"(0, rx248_pos, $I10)
+    set_addr $I10, rxcap_242_fail
+    rx238_cur."!mark_push"(0, rx238_pos, $I10)
   # rx literal  "$$"
-    add $I11, rx248_pos, 2
-    gt $I11, rx248_eos, rx248_fail
-    sub $I11, rx248_pos, rx248_off
-    substr $S10, rx248_tgt, $I11, 2
-    ne $S10, "$$", rx248_fail
-    add rx248_pos, 2
-    set_addr $I10, rxcap_252_fail
-    ($I12, $I11) = rx248_cur."!mark_peek"($I10)
-    rx248_cur."!cursor_pos"($I11)
-    ($P10) = rx248_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx248_pos, "")
-    rx248_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx238_pos, 2
+    gt $I11, rx238_eos, rx238_fail
+    sub $I11, rx238_pos, rx238_off
+    substr $S10, rx238_tgt, $I11, 2
+    ne $S10, "$$", rx238_fail
+    add rx238_pos, 2
+    set_addr $I10, rxcap_242_fail
+    ($I12, $I11) = rx238_cur."!mark_peek"($I10)
+    rx238_cur."!cursor_pos"($I11)
+    ($P10) = rx238_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx238_pos, "")
+    rx238_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_252_done
-  rxcap_252_fail:
-    goto rx248_fail
-  rxcap_252_done:
+    goto rxcap_242_done
+  rxcap_242_fail:
+    goto rx238_fail
+  rxcap_242_done:
   # rx pass
-    rx248_cur."!cursor_pass"(rx248_pos, "metachar:sym<$$>")
-    rx248_cur."!cursor_debug"("PASS  ", "metachar:sym<$$>", " at pos=", rx248_pos)
-    .return (rx248_cur)
-  rx248_fail:
+    rx238_cur."!cursor_pass"(rx238_pos, "metachar:sym<$$>")
+    rx238_cur."!cursor_debug"("PASS  ", "metachar:sym<$$>", " at pos=", rx238_pos)
+    .return (rx238_cur)
+  rx238_restart:
 .annotate 'line', 3
-    (rx248_rep, rx248_pos, $I10, $P10) = rx248_cur."!mark_fail"(0)
-    lt rx248_pos, -1, rx248_done
-    eq rx248_pos, -1, rx248_fail
+    rx238_cur."!cursor_debug"("NEXT ", "metachar:sym<$$>")
+  rx238_fail:
+    (rx238_rep, rx238_pos, $I10, $P10) = rx238_cur."!mark_fail"(0)
+    lt rx238_pos, -1, rx238_done
+    eq rx238_pos, -1, rx238_fail
     jump $I10
-  rx248_done:
-    rx248_cur."!cursor_fail"()
-    rx248_cur."!cursor_debug"("FAIL  ", "metachar:sym<$$>")
-    .return (rx248_cur)
+  rx238_done:
+    rx238_cur."!cursor_fail"()
+    rx238_cur."!cursor_debug"("FAIL  ", "metachar:sym<$$>")
+    .return (rx238_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<$$>"  :subid("70_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<$$>"  :subid("70_1279529218.55263") :method
 .annotate 'line', 3
-    new $P250, "ResizablePMCArray"
-    push $P250, "$$"
-    .return ($P250)
+    new $P240, "ResizablePMCArray"
+    push $P240, "$$"
+    .return ($P240)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<:::>"  :subid("71_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<:::>"  :subid("71_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx254_tgt
-    .local int rx254_pos
-    .local int rx254_off
-    .local int rx254_eos
-    .local int rx254_rep
-    .local pmc rx254_cur
-    (rx254_cur, rx254_pos, rx254_tgt) = self."!cursor_start"()
-    rx254_cur."!cursor_debug"("START ", "metachar:sym<:::>")
-    .lex unicode:"$\x{a2}", rx254_cur
+    .local string rx244_tgt
+    .local int rx244_pos
+    .local int rx244_off
+    .local int rx244_eos
+    .local int rx244_rep
+    .local pmc rx244_cur
+    (rx244_cur, rx244_pos, rx244_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx244_cur
     .local pmc match
     .lex "$/", match
-    length rx254_eos, rx254_tgt
-    gt rx254_pos, rx254_eos, rx254_done
-    set rx254_off, 0
-    lt rx254_pos, 2, rx254_start
-    sub rx254_off, rx254_pos, 1
-    substr rx254_tgt, rx254_tgt, rx254_off
-  rx254_start:
+    length rx244_eos, rx244_tgt
+    gt rx244_pos, rx244_eos, rx244_done
+    set rx244_off, 0
+    lt rx244_pos, 2, rx244_start
+    sub rx244_off, rx244_pos, 1
+    substr rx244_tgt, rx244_tgt, rx244_off
+  rx244_start:
+    eq $I10, 1, rx244_restart
+    rx244_cur."!cursor_debug"("START ", "metachar:sym<:::>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan258_done
-    goto rxscan258_scan
-  rxscan258_loop:
-    ($P10) = rx254_cur."from"()
+    ne $I10, -1, rxscan248_done
+    goto rxscan248_scan
+  rxscan248_loop:
+    ($P10) = rx244_cur."from"()
     inc $P10
-    set rx254_pos, $P10
-    ge rx254_pos, rx254_eos, rxscan258_done
-  rxscan258_scan:
-    set_addr $I10, rxscan258_loop
-    rx254_cur."!mark_push"(0, rx254_pos, $I10)
-  rxscan258_done:
+    set rx244_pos, $P10
+    ge rx244_pos, rx244_eos, rxscan248_done
+  rxscan248_scan:
+    set_addr $I10, rxscan248_loop
+    rx244_cur."!mark_push"(0, rx244_pos, $I10)
+  rxscan248_done:
 .annotate 'line', 86
   # rx subcapture "sym"
-    set_addr $I10, rxcap_259_fail
-    rx254_cur."!mark_push"(0, rx254_pos, $I10)
+    set_addr $I10, rxcap_249_fail
+    rx244_cur."!mark_push"(0, rx244_pos, $I10)
   # rx literal  ":::"
-    add $I11, rx254_pos, 3
-    gt $I11, rx254_eos, rx254_fail
-    sub $I11, rx254_pos, rx254_off
-    substr $S10, rx254_tgt, $I11, 3
-    ne $S10, ":::", rx254_fail
-    add rx254_pos, 3
-    set_addr $I10, rxcap_259_fail
-    ($I12, $I11) = rx254_cur."!mark_peek"($I10)
-    rx254_cur."!cursor_pos"($I11)
-    ($P10) = rx254_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx254_pos, "")
-    rx254_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx244_pos, 3
+    gt $I11, rx244_eos, rx244_fail
+    sub $I11, rx244_pos, rx244_off
+    substr $S10, rx244_tgt, $I11, 3
+    ne $S10, ":::", rx244_fail
+    add rx244_pos, 3
+    set_addr $I10, rxcap_249_fail
+    ($I12, $I11) = rx244_cur."!mark_peek"($I10)
+    rx244_cur."!cursor_pos"($I11)
+    ($P10) = rx244_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx244_pos, "")
+    rx244_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_259_done
-  rxcap_259_fail:
-    goto rx254_fail
-  rxcap_259_done:
+    goto rxcap_249_done
+  rxcap_249_fail:
+    goto rx244_fail
+  rxcap_249_done:
   # rx subrule "panic" subtype=method negate=
-    rx254_cur."!cursor_pos"(rx254_pos)
-    $P10 = rx254_cur."panic"("::: not yet implemented")
-    unless $P10, rx254_fail
-    rx254_pos = $P10."pos"()
+    rx244_cur."!cursor_pos"(rx244_pos)
+    $P10 = rx244_cur."panic"("::: not yet implemented")
+    unless $P10, rx244_fail
+    rx244_pos = $P10."pos"()
   # rx pass
-    rx254_cur."!cursor_pass"(rx254_pos, "metachar:sym<:::>")
-    rx254_cur."!cursor_debug"("PASS  ", "metachar:sym<:::>", " at pos=", rx254_pos)
-    .return (rx254_cur)
-  rx254_fail:
+    rx244_cur."!cursor_pass"(rx244_pos, "metachar:sym<:::>")
+    rx244_cur."!cursor_debug"("PASS  ", "metachar:sym<:::>", " at pos=", rx244_pos)
+    .return (rx244_cur)
+  rx244_restart:
 .annotate 'line', 3
-    (rx254_rep, rx254_pos, $I10, $P10) = rx254_cur."!mark_fail"(0)
-    lt rx254_pos, -1, rx254_done
-    eq rx254_pos, -1, rx254_fail
+    rx244_cur."!cursor_debug"("NEXT ", "metachar:sym<:::>")
+  rx244_fail:
+    (rx244_rep, rx244_pos, $I10, $P10) = rx244_cur."!mark_fail"(0)
+    lt rx244_pos, -1, rx244_done
+    eq rx244_pos, -1, rx244_fail
     jump $I10
-  rx254_done:
-    rx254_cur."!cursor_fail"()
-    rx254_cur."!cursor_debug"("FAIL  ", "metachar:sym<:::>")
-    .return (rx254_cur)
+  rx244_done:
+    rx244_cur."!cursor_fail"()
+    rx244_cur."!cursor_debug"("FAIL  ", "metachar:sym<:::>")
+    .return (rx244_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<:::>"  :subid("72_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<:::>"  :subid("72_1279529218.55263") :method
 .annotate 'line', 3
-    $P256 = self."!PREFIX__!subrule"("panic", ":::")
-    new $P257, "ResizablePMCArray"
-    push $P257, $P256
-    .return ($P257)
+    $P246 = self."!PREFIX__!subrule"("panic", ":::")
+    new $P247, "ResizablePMCArray"
+    push $P247, $P246
+    .return ($P247)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<::>"  :subid("73_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<::>"  :subid("73_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx261_tgt
-    .local int rx261_pos
-    .local int rx261_off
-    .local int rx261_eos
-    .local int rx261_rep
-    .local pmc rx261_cur
-    (rx261_cur, rx261_pos, rx261_tgt) = self."!cursor_start"()
-    rx261_cur."!cursor_debug"("START ", "metachar:sym<::>")
-    .lex unicode:"$\x{a2}", rx261_cur
+    .local string rx251_tgt
+    .local int rx251_pos
+    .local int rx251_off
+    .local int rx251_eos
+    .local int rx251_rep
+    .local pmc rx251_cur
+    (rx251_cur, rx251_pos, rx251_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx251_cur
     .local pmc match
     .lex "$/", match
-    length rx261_eos, rx261_tgt
-    gt rx261_pos, rx261_eos, rx261_done
-    set rx261_off, 0
-    lt rx261_pos, 2, rx261_start
-    sub rx261_off, rx261_pos, 1
-    substr rx261_tgt, rx261_tgt, rx261_off
-  rx261_start:
+    length rx251_eos, rx251_tgt
+    gt rx251_pos, rx251_eos, rx251_done
+    set rx251_off, 0
+    lt rx251_pos, 2, rx251_start
+    sub rx251_off, rx251_pos, 1
+    substr rx251_tgt, rx251_tgt, rx251_off
+  rx251_start:
+    eq $I10, 1, rx251_restart
+    rx251_cur."!cursor_debug"("START ", "metachar:sym<::>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan265_done
-    goto rxscan265_scan
-  rxscan265_loop:
-    ($P10) = rx261_cur."from"()
+    ne $I10, -1, rxscan255_done
+    goto rxscan255_scan
+  rxscan255_loop:
+    ($P10) = rx251_cur."from"()
     inc $P10
-    set rx261_pos, $P10
-    ge rx261_pos, rx261_eos, rxscan265_done
-  rxscan265_scan:
-    set_addr $I10, rxscan265_loop
-    rx261_cur."!mark_push"(0, rx261_pos, $I10)
-  rxscan265_done:
+    set rx251_pos, $P10
+    ge rx251_pos, rx251_eos, rxscan255_done
+  rxscan255_scan:
+    set_addr $I10, rxscan255_loop
+    rx251_cur."!mark_push"(0, rx251_pos, $I10)
+  rxscan255_done:
 .annotate 'line', 87
   # rx subcapture "sym"
-    set_addr $I10, rxcap_266_fail
-    rx261_cur."!mark_push"(0, rx261_pos, $I10)
+    set_addr $I10, rxcap_256_fail
+    rx251_cur."!mark_push"(0, rx251_pos, $I10)
   # rx literal  "::"
-    add $I11, rx261_pos, 2
-    gt $I11, rx261_eos, rx261_fail
-    sub $I11, rx261_pos, rx261_off
-    substr $S10, rx261_tgt, $I11, 2
-    ne $S10, "::", rx261_fail
-    add rx261_pos, 2
-    set_addr $I10, rxcap_266_fail
-    ($I12, $I11) = rx261_cur."!mark_peek"($I10)
-    rx261_cur."!cursor_pos"($I11)
-    ($P10) = rx261_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx261_pos, "")
-    rx261_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx251_pos, 2
+    gt $I11, rx251_eos, rx251_fail
+    sub $I11, rx251_pos, rx251_off
+    substr $S10, rx251_tgt, $I11, 2
+    ne $S10, "::", rx251_fail
+    add rx251_pos, 2
+    set_addr $I10, rxcap_256_fail
+    ($I12, $I11) = rx251_cur."!mark_peek"($I10)
+    rx251_cur."!cursor_pos"($I11)
+    ($P10) = rx251_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx251_pos, "")
+    rx251_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_266_done
-  rxcap_266_fail:
-    goto rx261_fail
-  rxcap_266_done:
+    goto rxcap_256_done
+  rxcap_256_fail:
+    goto rx251_fail
+  rxcap_256_done:
   # rx subrule "panic" subtype=method negate=
-    rx261_cur."!cursor_pos"(rx261_pos)
-    $P10 = rx261_cur."panic"(":: not yet implemented")
-    unless $P10, rx261_fail
-    rx261_pos = $P10."pos"()
+    rx251_cur."!cursor_pos"(rx251_pos)
+    $P10 = rx251_cur."panic"(":: not yet implemented")
+    unless $P10, rx251_fail
+    rx251_pos = $P10."pos"()
   # rx pass
-    rx261_cur."!cursor_pass"(rx261_pos, "metachar:sym<::>")
-    rx261_cur."!cursor_debug"("PASS  ", "metachar:sym<::>", " at pos=", rx261_pos)
-    .return (rx261_cur)
-  rx261_fail:
+    rx251_cur."!cursor_pass"(rx251_pos, "metachar:sym<::>")
+    rx251_cur."!cursor_debug"("PASS  ", "metachar:sym<::>", " at pos=", rx251_pos)
+    .return (rx251_cur)
+  rx251_restart:
 .annotate 'line', 3
-    (rx261_rep, rx261_pos, $I10, $P10) = rx261_cur."!mark_fail"(0)
-    lt rx261_pos, -1, rx261_done
-    eq rx261_pos, -1, rx261_fail
+    rx251_cur."!cursor_debug"("NEXT ", "metachar:sym<::>")
+  rx251_fail:
+    (rx251_rep, rx251_pos, $I10, $P10) = rx251_cur."!mark_fail"(0)
+    lt rx251_pos, -1, rx251_done
+    eq rx251_pos, -1, rx251_fail
     jump $I10
-  rx261_done:
-    rx261_cur."!cursor_fail"()
-    rx261_cur."!cursor_debug"("FAIL  ", "metachar:sym<::>")
-    .return (rx261_cur)
+  rx251_done:
+    rx251_cur."!cursor_fail"()
+    rx251_cur."!cursor_debug"("FAIL  ", "metachar:sym<::>")
+    .return (rx251_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<::>"  :subid("74_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<::>"  :subid("74_1279529218.55263") :method
 .annotate 'line', 3
-    $P263 = self."!PREFIX__!subrule"("panic", "::")
-    new $P264, "ResizablePMCArray"
-    push $P264, $P263
-    .return ($P264)
+    $P253 = self."!PREFIX__!subrule"("panic", "::")
+    new $P254, "ResizablePMCArray"
+    push $P254, $P253
+    .return ($P254)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<lwb>"  :subid("75_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<lwb>"  :subid("75_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx268_tgt
-    .local int rx268_pos
-    .local int rx268_off
-    .local int rx268_eos
-    .local int rx268_rep
-    .local pmc rx268_cur
-    (rx268_cur, rx268_pos, rx268_tgt) = self."!cursor_start"()
-    rx268_cur."!cursor_debug"("START ", "metachar:sym<lwb>")
-    .lex unicode:"$\x{a2}", rx268_cur
+    .local string rx258_tgt
+    .local int rx258_pos
+    .local int rx258_off
+    .local int rx258_eos
+    .local int rx258_rep
+    .local pmc rx258_cur
+    (rx258_cur, rx258_pos, rx258_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx258_cur
     .local pmc match
     .lex "$/", match
-    length rx268_eos, rx268_tgt
-    gt rx268_pos, rx268_eos, rx268_done
-    set rx268_off, 0
-    lt rx268_pos, 2, rx268_start
-    sub rx268_off, rx268_pos, 1
-    substr rx268_tgt, rx268_tgt, rx268_off
-  rx268_start:
+    length rx258_eos, rx258_tgt
+    gt rx258_pos, rx258_eos, rx258_done
+    set rx258_off, 0
+    lt rx258_pos, 2, rx258_start
+    sub rx258_off, rx258_pos, 1
+    substr rx258_tgt, rx258_tgt, rx258_off
+  rx258_start:
+    eq $I10, 1, rx258_restart
+    rx258_cur."!cursor_debug"("START ", "metachar:sym<lwb>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan271_done
-    goto rxscan271_scan
-  rxscan271_loop:
-    ($P10) = rx268_cur."from"()
+    ne $I10, -1, rxscan261_done
+    goto rxscan261_scan
+  rxscan261_loop:
+    ($P10) = rx258_cur."from"()
     inc $P10
-    set rx268_pos, $P10
-    ge rx268_pos, rx268_eos, rxscan271_done
-  rxscan271_scan:
-    set_addr $I10, rxscan271_loop
-    rx268_cur."!mark_push"(0, rx268_pos, $I10)
-  rxscan271_done:
+    set rx258_pos, $P10
+    ge rx258_pos, rx258_eos, rxscan261_done
+  rxscan261_scan:
+    set_addr $I10, rxscan261_loop
+    rx258_cur."!mark_push"(0, rx258_pos, $I10)
+  rxscan261_done:
 .annotate 'line', 88
   # rx subcapture "sym"
-    set_addr $I10, rxcap_273_fail
-    rx268_cur."!mark_push"(0, rx268_pos, $I10)
-  alt272_0:
-    set_addr $I10, alt272_1
-    rx268_cur."!mark_push"(0, rx268_pos, $I10)
+    set_addr $I10, rxcap_263_fail
+    rx258_cur."!mark_push"(0, rx258_pos, $I10)
+  alt262_0:
+    set_addr $I10, alt262_1
+    rx258_cur."!mark_push"(0, rx258_pos, $I10)
   # rx literal  "<<"
-    add $I11, rx268_pos, 2
-    gt $I11, rx268_eos, rx268_fail
-    sub $I11, rx268_pos, rx268_off
-    substr $S10, rx268_tgt, $I11, 2
-    ne $S10, "<<", rx268_fail
-    add rx268_pos, 2
-    goto alt272_end
-  alt272_1:
+    add $I11, rx258_pos, 2
+    gt $I11, rx258_eos, rx258_fail
+    sub $I11, rx258_pos, rx258_off
+    substr $S10, rx258_tgt, $I11, 2
+    ne $S10, "<<", rx258_fail
+    add rx258_pos, 2
+    goto alt262_end
+  alt262_1:
   # rx literal  unicode:"\x{ab}"
-    add $I11, rx268_pos, 1
-    gt $I11, rx268_eos, rx268_fail
-    sub $I11, rx268_pos, rx268_off
-    substr $S10, rx268_tgt, $I11, 1
-    ne $S10, unicode:"\x{ab}", rx268_fail
-    add rx268_pos, 1
-  alt272_end:
-    set_addr $I10, rxcap_273_fail
-    ($I12, $I11) = rx268_cur."!mark_peek"($I10)
-    rx268_cur."!cursor_pos"($I11)
-    ($P10) = rx268_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx268_pos, "")
-    rx268_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx258_pos, 1
+    gt $I11, rx258_eos, rx258_fail
+    sub $I11, rx258_pos, rx258_off
+    substr $S10, rx258_tgt, $I11, 1
+    ne $S10, unicode:"\x{ab}", rx258_fail
+    add rx258_pos, 1
+  alt262_end:
+    set_addr $I10, rxcap_263_fail
+    ($I12, $I11) = rx258_cur."!mark_peek"($I10)
+    rx258_cur."!cursor_pos"($I11)
+    ($P10) = rx258_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx258_pos, "")
+    rx258_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_273_done
-  rxcap_273_fail:
-    goto rx268_fail
-  rxcap_273_done:
+    goto rxcap_263_done
+  rxcap_263_fail:
+    goto rx258_fail
+  rxcap_263_done:
   # rx pass
-    rx268_cur."!cursor_pass"(rx268_pos, "metachar:sym<lwb>")
-    rx268_cur."!cursor_debug"("PASS  ", "metachar:sym<lwb>", " at pos=", rx268_pos)
-    .return (rx268_cur)
-  rx268_fail:
+    rx258_cur."!cursor_pass"(rx258_pos, "metachar:sym<lwb>")
+    rx258_cur."!cursor_debug"("PASS  ", "metachar:sym<lwb>", " at pos=", rx258_pos)
+    .return (rx258_cur)
+  rx258_restart:
 .annotate 'line', 3
-    (rx268_rep, rx268_pos, $I10, $P10) = rx268_cur."!mark_fail"(0)
-    lt rx268_pos, -1, rx268_done
-    eq rx268_pos, -1, rx268_fail
+    rx258_cur."!cursor_debug"("NEXT ", "metachar:sym<lwb>")
+  rx258_fail:
+    (rx258_rep, rx258_pos, $I10, $P10) = rx258_cur."!mark_fail"(0)
+    lt rx258_pos, -1, rx258_done
+    eq rx258_pos, -1, rx258_fail
     jump $I10
-  rx268_done:
-    rx268_cur."!cursor_fail"()
-    rx268_cur."!cursor_debug"("FAIL  ", "metachar:sym<lwb>")
-    .return (rx268_cur)
+  rx258_done:
+    rx258_cur."!cursor_fail"()
+    rx258_cur."!cursor_debug"("FAIL  ", "metachar:sym<lwb>")
+    .return (rx258_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<lwb>"  :subid("76_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<lwb>"  :subid("76_1279529218.55263") :method
 .annotate 'line', 3
-    new $P270, "ResizablePMCArray"
-    push $P270, unicode:"\x{ab}"
-    push $P270, "<<"
-    .return ($P270)
+    new $P260, "ResizablePMCArray"
+    push $P260, unicode:"\x{ab}"
+    push $P260, "<<"
+    .return ($P260)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<rwb>"  :subid("77_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<rwb>"  :subid("77_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx275_tgt
-    .local int rx275_pos
-    .local int rx275_off
-    .local int rx275_eos
-    .local int rx275_rep
-    .local pmc rx275_cur
-    (rx275_cur, rx275_pos, rx275_tgt) = self."!cursor_start"()
-    rx275_cur."!cursor_debug"("START ", "metachar:sym<rwb>")
-    .lex unicode:"$\x{a2}", rx275_cur
+    .local string rx265_tgt
+    .local int rx265_pos
+    .local int rx265_off
+    .local int rx265_eos
+    .local int rx265_rep
+    .local pmc rx265_cur
+    (rx265_cur, rx265_pos, rx265_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx265_cur
     .local pmc match
     .lex "$/", match
-    length rx275_eos, rx275_tgt
-    gt rx275_pos, rx275_eos, rx275_done
-    set rx275_off, 0
-    lt rx275_pos, 2, rx275_start
-    sub rx275_off, rx275_pos, 1
-    substr rx275_tgt, rx275_tgt, rx275_off
-  rx275_start:
+    length rx265_eos, rx265_tgt
+    gt rx265_pos, rx265_eos, rx265_done
+    set rx265_off, 0
+    lt rx265_pos, 2, rx265_start
+    sub rx265_off, rx265_pos, 1
+    substr rx265_tgt, rx265_tgt, rx265_off
+  rx265_start:
+    eq $I10, 1, rx265_restart
+    rx265_cur."!cursor_debug"("START ", "metachar:sym<rwb>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan278_done
-    goto rxscan278_scan
-  rxscan278_loop:
-    ($P10) = rx275_cur."from"()
+    ne $I10, -1, rxscan268_done
+    goto rxscan268_scan
+  rxscan268_loop:
+    ($P10) = rx265_cur."from"()
     inc $P10
-    set rx275_pos, $P10
-    ge rx275_pos, rx275_eos, rxscan278_done
-  rxscan278_scan:
-    set_addr $I10, rxscan278_loop
-    rx275_cur."!mark_push"(0, rx275_pos, $I10)
-  rxscan278_done:
+    set rx265_pos, $P10
+    ge rx265_pos, rx265_eos, rxscan268_done
+  rxscan268_scan:
+    set_addr $I10, rxscan268_loop
+    rx265_cur."!mark_push"(0, rx265_pos, $I10)
+  rxscan268_done:
 .annotate 'line', 89
   # rx subcapture "sym"
-    set_addr $I10, rxcap_280_fail
-    rx275_cur."!mark_push"(0, rx275_pos, $I10)
-  alt279_0:
-    set_addr $I10, alt279_1
-    rx275_cur."!mark_push"(0, rx275_pos, $I10)
+    set_addr $I10, rxcap_270_fail
+    rx265_cur."!mark_push"(0, rx265_pos, $I10)
+  alt269_0:
+    set_addr $I10, alt269_1
+    rx265_cur."!mark_push"(0, rx265_pos, $I10)
   # rx literal  ">>"
-    add $I11, rx275_pos, 2
-    gt $I11, rx275_eos, rx275_fail
-    sub $I11, rx275_pos, rx275_off
-    substr $S10, rx275_tgt, $I11, 2
-    ne $S10, ">>", rx275_fail
-    add rx275_pos, 2
-    goto alt279_end
-  alt279_1:
+    add $I11, rx265_pos, 2
+    gt $I11, rx265_eos, rx265_fail
+    sub $I11, rx265_pos, rx265_off
+    substr $S10, rx265_tgt, $I11, 2
+    ne $S10, ">>", rx265_fail
+    add rx265_pos, 2
+    goto alt269_end
+  alt269_1:
   # rx literal  unicode:"\x{bb}"
-    add $I11, rx275_pos, 1
-    gt $I11, rx275_eos, rx275_fail
-    sub $I11, rx275_pos, rx275_off
-    substr $S10, rx275_tgt, $I11, 1
-    ne $S10, unicode:"\x{bb}", rx275_fail
-    add rx275_pos, 1
-  alt279_end:
-    set_addr $I10, rxcap_280_fail
-    ($I12, $I11) = rx275_cur."!mark_peek"($I10)
-    rx275_cur."!cursor_pos"($I11)
-    ($P10) = rx275_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx275_pos, "")
-    rx275_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx265_pos, 1
+    gt $I11, rx265_eos, rx265_fail
+    sub $I11, rx265_pos, rx265_off
+    substr $S10, rx265_tgt, $I11, 1
+    ne $S10, unicode:"\x{bb}", rx265_fail
+    add rx265_pos, 1
+  alt269_end:
+    set_addr $I10, rxcap_270_fail
+    ($I12, $I11) = rx265_cur."!mark_peek"($I10)
+    rx265_cur."!cursor_pos"($I11)
+    ($P10) = rx265_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx265_pos, "")
+    rx265_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_280_done
-  rxcap_280_fail:
-    goto rx275_fail
-  rxcap_280_done:
+    goto rxcap_270_done
+  rxcap_270_fail:
+    goto rx265_fail
+  rxcap_270_done:
   # rx pass
-    rx275_cur."!cursor_pass"(rx275_pos, "metachar:sym<rwb>")
-    rx275_cur."!cursor_debug"("PASS  ", "metachar:sym<rwb>", " at pos=", rx275_pos)
-    .return (rx275_cur)
-  rx275_fail:
+    rx265_cur."!cursor_pass"(rx265_pos, "metachar:sym<rwb>")
+    rx265_cur."!cursor_debug"("PASS  ", "metachar:sym<rwb>", " at pos=", rx265_pos)
+    .return (rx265_cur)
+  rx265_restart:
 .annotate 'line', 3
-    (rx275_rep, rx275_pos, $I10, $P10) = rx275_cur."!mark_fail"(0)
-    lt rx275_pos, -1, rx275_done
-    eq rx275_pos, -1, rx275_fail
+    rx265_cur."!cursor_debug"("NEXT ", "metachar:sym<rwb>")
+  rx265_fail:
+    (rx265_rep, rx265_pos, $I10, $P10) = rx265_cur."!mark_fail"(0)
+    lt rx265_pos, -1, rx265_done
+    eq rx265_pos, -1, rx265_fail
     jump $I10
-  rx275_done:
-    rx275_cur."!cursor_fail"()
-    rx275_cur."!cursor_debug"("FAIL  ", "metachar:sym<rwb>")
-    .return (rx275_cur)
+  rx265_done:
+    rx265_cur."!cursor_fail"()
+    rx265_cur."!cursor_debug"("FAIL  ", "metachar:sym<rwb>")
+    .return (rx265_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<rwb>"  :subid("78_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<rwb>"  :subid("78_1279529218.55263") :method
 .annotate 'line', 3
-    new $P277, "ResizablePMCArray"
-    push $P277, unicode:"\x{bb}"
-    push $P277, ">>"
-    .return ($P277)
+    new $P267, "ResizablePMCArray"
+    push $P267, unicode:"\x{bb}"
+    push $P267, ">>"
+    .return ($P267)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<bs>"  :subid("79_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<bs>"  :subid("79_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx282_tgt
-    .local int rx282_pos
-    .local int rx282_off
-    .local int rx282_eos
-    .local int rx282_rep
-    .local pmc rx282_cur
-    (rx282_cur, rx282_pos, rx282_tgt) = self."!cursor_start"()
-    rx282_cur."!cursor_debug"("START ", "metachar:sym<bs>")
-    .lex unicode:"$\x{a2}", rx282_cur
+    .local string rx272_tgt
+    .local int rx272_pos
+    .local int rx272_off
+    .local int rx272_eos
+    .local int rx272_rep
+    .local pmc rx272_cur
+    (rx272_cur, rx272_pos, rx272_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx272_cur
     .local pmc match
     .lex "$/", match
-    length rx282_eos, rx282_tgt
-    gt rx282_pos, rx282_eos, rx282_done
-    set rx282_off, 0
-    lt rx282_pos, 2, rx282_start
-    sub rx282_off, rx282_pos, 1
-    substr rx282_tgt, rx282_tgt, rx282_off
-  rx282_start:
+    length rx272_eos, rx272_tgt
+    gt rx272_pos, rx272_eos, rx272_done
+    set rx272_off, 0
+    lt rx272_pos, 2, rx272_start
+    sub rx272_off, rx272_pos, 1
+    substr rx272_tgt, rx272_tgt, rx272_off
+  rx272_start:
+    eq $I10, 1, rx272_restart
+    rx272_cur."!cursor_debug"("START ", "metachar:sym<bs>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan286_done
-    goto rxscan286_scan
-  rxscan286_loop:
-    ($P10) = rx282_cur."from"()
+    ne $I10, -1, rxscan276_done
+    goto rxscan276_scan
+  rxscan276_loop:
+    ($P10) = rx272_cur."from"()
     inc $P10
-    set rx282_pos, $P10
-    ge rx282_pos, rx282_eos, rxscan286_done
-  rxscan286_scan:
-    set_addr $I10, rxscan286_loop
-    rx282_cur."!mark_push"(0, rx282_pos, $I10)
-  rxscan286_done:
+    set rx272_pos, $P10
+    ge rx272_pos, rx272_eos, rxscan276_done
+  rxscan276_scan:
+    set_addr $I10, rxscan276_loop
+    rx272_cur."!mark_push"(0, rx272_pos, $I10)
+  rxscan276_done:
 .annotate 'line', 90
   # rx literal  "\\"
-    add $I11, rx282_pos, 1
-    gt $I11, rx282_eos, rx282_fail
-    sub $I11, rx282_pos, rx282_off
-    substr $S10, rx282_tgt, $I11, 1
-    ne $S10, "\\", rx282_fail
-    add rx282_pos, 1
+    add $I11, rx272_pos, 1
+    gt $I11, rx272_eos, rx272_fail
+    sub $I11, rx272_pos, rx272_off
+    substr $S10, rx272_tgt, $I11, 1
+    ne $S10, "\\", rx272_fail
+    add rx272_pos, 1
   # rx subrule "backslash" subtype=capture negate=
-    rx282_cur."!cursor_pos"(rx282_pos)
-    $P10 = rx282_cur."backslash"()
-    unless $P10, rx282_fail
-    rx282_cur."!mark_push"(0, -1, 0, $P10)
+    rx272_cur."!cursor_pos"(rx272_pos)
+    $P10 = rx272_cur."backslash"()
+    unless $P10, rx272_fail
+    rx272_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("backslash")
-    rx282_pos = $P10."pos"()
+    rx272_pos = $P10."pos"()
   # rx pass
-    rx282_cur."!cursor_pass"(rx282_pos, "metachar:sym<bs>")
-    rx282_cur."!cursor_debug"("PASS  ", "metachar:sym<bs>", " at pos=", rx282_pos)
-    .return (rx282_cur)
-  rx282_fail:
+    rx272_cur."!cursor_pass"(rx272_pos, "metachar:sym<bs>")
+    rx272_cur."!cursor_debug"("PASS  ", "metachar:sym<bs>", " at pos=", rx272_pos)
+    .return (rx272_cur)
+  rx272_restart:
 .annotate 'line', 3
-    (rx282_rep, rx282_pos, $I10, $P10) = rx282_cur."!mark_fail"(0)
-    lt rx282_pos, -1, rx282_done
-    eq rx282_pos, -1, rx282_fail
+    rx272_cur."!cursor_debug"("NEXT ", "metachar:sym<bs>")
+  rx272_fail:
+    (rx272_rep, rx272_pos, $I10, $P10) = rx272_cur."!mark_fail"(0)
+    lt rx272_pos, -1, rx272_done
+    eq rx272_pos, -1, rx272_fail
     jump $I10
-  rx282_done:
-    rx282_cur."!cursor_fail"()
-    rx282_cur."!cursor_debug"("FAIL  ", "metachar:sym<bs>")
-    .return (rx282_cur)
+  rx272_done:
+    rx272_cur."!cursor_fail"()
+    rx272_cur."!cursor_debug"("FAIL  ", "metachar:sym<bs>")
+    .return (rx272_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<bs>"  :subid("80_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<bs>"  :subid("80_1279529218.55263") :method
 .annotate 'line', 3
-    $P284 = self."!PREFIX__!subrule"("backslash", "\\")
-    new $P285, "ResizablePMCArray"
-    push $P285, $P284
-    .return ($P285)
+    $P274 = self."!PREFIX__!subrule"("backslash", "\\")
+    new $P275, "ResizablePMCArray"
+    push $P275, $P274
+    .return ($P275)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<mod>"  :subid("81_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<mod>"  :subid("81_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx288_tgt
-    .local int rx288_pos
-    .local int rx288_off
-    .local int rx288_eos
-    .local int rx288_rep
-    .local pmc rx288_cur
-    (rx288_cur, rx288_pos, rx288_tgt) = self."!cursor_start"()
-    rx288_cur."!cursor_debug"("START ", "metachar:sym<mod>")
-    .lex unicode:"$\x{a2}", rx288_cur
+    .local string rx278_tgt
+    .local int rx278_pos
+    .local int rx278_off
+    .local int rx278_eos
+    .local int rx278_rep
+    .local pmc rx278_cur
+    (rx278_cur, rx278_pos, rx278_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx278_cur
     .local pmc match
     .lex "$/", match
-    length rx288_eos, rx288_tgt
-    gt rx288_pos, rx288_eos, rx288_done
-    set rx288_off, 0
-    lt rx288_pos, 2, rx288_start
-    sub rx288_off, rx288_pos, 1
-    substr rx288_tgt, rx288_tgt, rx288_off
-  rx288_start:
+    length rx278_eos, rx278_tgt
+    gt rx278_pos, rx278_eos, rx278_done
+    set rx278_off, 0
+    lt rx278_pos, 2, rx278_start
+    sub rx278_off, rx278_pos, 1
+    substr rx278_tgt, rx278_tgt, rx278_off
+  rx278_start:
+    eq $I10, 1, rx278_restart
+    rx278_cur."!cursor_debug"("START ", "metachar:sym<mod>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan292_done
-    goto rxscan292_scan
-  rxscan292_loop:
-    ($P10) = rx288_cur."from"()
+    ne $I10, -1, rxscan282_done
+    goto rxscan282_scan
+  rxscan282_loop:
+    ($P10) = rx278_cur."from"()
     inc $P10
-    set rx288_pos, $P10
-    ge rx288_pos, rx288_eos, rxscan292_done
-  rxscan292_scan:
-    set_addr $I10, rxscan292_loop
-    rx288_cur."!mark_push"(0, rx288_pos, $I10)
-  rxscan292_done:
+    set rx278_pos, $P10
+    ge rx278_pos, rx278_eos, rxscan282_done
+  rxscan282_scan:
+    set_addr $I10, rxscan282_loop
+    rx278_cur."!mark_push"(0, rx278_pos, $I10)
+  rxscan282_done:
 .annotate 'line', 91
   # rx subrule "mod_internal" subtype=capture negate=
-    rx288_cur."!cursor_pos"(rx288_pos)
-    $P10 = rx288_cur."mod_internal"()
-    unless $P10, rx288_fail
-    rx288_cur."!mark_push"(0, -1, 0, $P10)
+    rx278_cur."!cursor_pos"(rx278_pos)
+    $P10 = rx278_cur."mod_internal"()
+    unless $P10, rx278_fail
+    rx278_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("mod_internal")
-    rx288_pos = $P10."pos"()
+    rx278_pos = $P10."pos"()
   # rx pass
-    rx288_cur."!cursor_pass"(rx288_pos, "metachar:sym<mod>")
-    rx288_cur."!cursor_debug"("PASS  ", "metachar:sym<mod>", " at pos=", rx288_pos)
-    .return (rx288_cur)
-  rx288_fail:
+    rx278_cur."!cursor_pass"(rx278_pos, "metachar:sym<mod>")
+    rx278_cur."!cursor_debug"("PASS  ", "metachar:sym<mod>", " at pos=", rx278_pos)
+    .return (rx278_cur)
+  rx278_restart:
 .annotate 'line', 3
-    (rx288_rep, rx288_pos, $I10, $P10) = rx288_cur."!mark_fail"(0)
-    lt rx288_pos, -1, rx288_done
-    eq rx288_pos, -1, rx288_fail
+    rx278_cur."!cursor_debug"("NEXT ", "metachar:sym<mod>")
+  rx278_fail:
+    (rx278_rep, rx278_pos, $I10, $P10) = rx278_cur."!mark_fail"(0)
+    lt rx278_pos, -1, rx278_done
+    eq rx278_pos, -1, rx278_fail
     jump $I10
-  rx288_done:
-    rx288_cur."!cursor_fail"()
-    rx288_cur."!cursor_debug"("FAIL  ", "metachar:sym<mod>")
-    .return (rx288_cur)
+  rx278_done:
+    rx278_cur."!cursor_fail"()
+    rx278_cur."!cursor_debug"("FAIL  ", "metachar:sym<mod>")
+    .return (rx278_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<mod>"  :subid("82_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<mod>"  :subid("82_1279529218.55263") :method
 .annotate 'line', 3
-    $P290 = self."!PREFIX__!subrule"("mod_internal", "")
-    new $P291, "ResizablePMCArray"
-    push $P291, $P290
-    .return ($P291)
+    $P280 = self."!PREFIX__!subrule"("mod_internal", "")
+    new $P281, "ResizablePMCArray"
+    push $P281, $P280
+    .return ($P281)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<~>"  :subid("83_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<~>"  :subid("83_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx294_tgt
-    .local int rx294_pos
-    .local int rx294_off
-    .local int rx294_eos
-    .local int rx294_rep
-    .local pmc rx294_cur
-    (rx294_cur, rx294_pos, rx294_tgt) = self."!cursor_start"()
-    rx294_cur."!cursor_debug"("START ", "metachar:sym<~>")
-    .lex unicode:"$\x{a2}", rx294_cur
+    .local string rx284_tgt
+    .local int rx284_pos
+    .local int rx284_off
+    .local int rx284_eos
+    .local int rx284_rep
+    .local pmc rx284_cur
+    (rx284_cur, rx284_pos, rx284_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx284_cur
     .local pmc match
     .lex "$/", match
-    length rx294_eos, rx294_tgt
-    gt rx294_pos, rx294_eos, rx294_done
-    set rx294_off, 0
-    lt rx294_pos, 2, rx294_start
-    sub rx294_off, rx294_pos, 1
-    substr rx294_tgt, rx294_tgt, rx294_off
-  rx294_start:
+    length rx284_eos, rx284_tgt
+    gt rx284_pos, rx284_eos, rx284_done
+    set rx284_off, 0
+    lt rx284_pos, 2, rx284_start
+    sub rx284_off, rx284_pos, 1
+    substr rx284_tgt, rx284_tgt, rx284_off
+  rx284_start:
+    eq $I10, 1, rx284_restart
+    rx284_cur."!cursor_debug"("START ", "metachar:sym<~>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan298_done
-    goto rxscan298_scan
-  rxscan298_loop:
-    ($P10) = rx294_cur."from"()
+    ne $I10, -1, rxscan288_done
+    goto rxscan288_scan
+  rxscan288_loop:
+    ($P10) = rx284_cur."from"()
     inc $P10
-    set rx294_pos, $P10
-    ge rx294_pos, rx294_eos, rxscan298_done
-  rxscan298_scan:
-    set_addr $I10, rxscan298_loop
-    rx294_cur."!mark_push"(0, rx294_pos, $I10)
-  rxscan298_done:
+    set rx284_pos, $P10
+    ge rx284_pos, rx284_eos, rxscan288_done
+  rxscan288_scan:
+    set_addr $I10, rxscan288_loop
+    rx284_cur."!mark_push"(0, rx284_pos, $I10)
+  rxscan288_done:
 .annotate 'line', 95
   # rx subcapture "sym"
-    set_addr $I10, rxcap_299_fail
-    rx294_cur."!mark_push"(0, rx294_pos, $I10)
+    set_addr $I10, rxcap_289_fail
+    rx284_cur."!mark_push"(0, rx284_pos, $I10)
   # rx literal  "~"
-    add $I11, rx294_pos, 1
-    gt $I11, rx294_eos, rx294_fail
-    sub $I11, rx294_pos, rx294_off
-    substr $S10, rx294_tgt, $I11, 1
-    ne $S10, "~", rx294_fail
-    add rx294_pos, 1
-    set_addr $I10, rxcap_299_fail
-    ($I12, $I11) = rx294_cur."!mark_peek"($I10)
-    rx294_cur."!cursor_pos"($I11)
-    ($P10) = rx294_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx294_pos, "")
-    rx294_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx284_pos, 1
+    gt $I11, rx284_eos, rx284_fail
+    sub $I11, rx284_pos, rx284_off
+    substr $S10, rx284_tgt, $I11, 1
+    ne $S10, "~", rx284_fail
+    add rx284_pos, 1
+    set_addr $I10, rxcap_289_fail
+    ($I12, $I11) = rx284_cur."!mark_peek"($I10)
+    rx284_cur."!cursor_pos"($I11)
+    ($P10) = rx284_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx284_pos, "")
+    rx284_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_299_done
-  rxcap_299_fail:
-    goto rx294_fail
-  rxcap_299_done:
+    goto rxcap_289_done
+  rxcap_289_fail:
+    goto rx284_fail
+  rxcap_289_done:
 .annotate 'line', 96
   # rx subrule "ws" subtype=method negate=
-    rx294_cur."!cursor_pos"(rx294_pos)
-    $P10 = rx294_cur."ws"()
-    unless $P10, rx294_fail
-    rx294_pos = $P10."pos"()
+    rx284_cur."!cursor_pos"(rx284_pos)
+    $P10 = rx284_cur."ws"()
+    unless $P10, rx284_fail
+    rx284_pos = $P10."pos"()
   # rx subrule "quantified_atom" subtype=capture negate=
-    rx294_cur."!cursor_pos"(rx294_pos)
-    $P10 = rx294_cur."quantified_atom"()
-    unless $P10, rx294_fail
-    rx294_cur."!mark_push"(0, -1, 0, $P10)
+    rx284_cur."!cursor_pos"(rx284_pos)
+    $P10 = rx284_cur."quantified_atom"()
+    unless $P10, rx284_fail
+    rx284_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("GOAL")
-    rx294_pos = $P10."pos"()
+    rx284_pos = $P10."pos"()
 .annotate 'line', 97
   # rx subrule "ws" subtype=method negate=
-    rx294_cur."!cursor_pos"(rx294_pos)
-    $P10 = rx294_cur."ws"()
-    unless $P10, rx294_fail
-    rx294_pos = $P10."pos"()
+    rx284_cur."!cursor_pos"(rx284_pos)
+    $P10 = rx284_cur."ws"()
+    unless $P10, rx284_fail
+    rx284_pos = $P10."pos"()
   # rx subrule "quantified_atom" subtype=capture negate=
-    rx294_cur."!cursor_pos"(rx294_pos)
-    $P10 = rx294_cur."quantified_atom"()
-    unless $P10, rx294_fail
-    rx294_cur."!mark_push"(0, -1, 0, $P10)
+    rx284_cur."!cursor_pos"(rx284_pos)
+    $P10 = rx284_cur."quantified_atom"()
+    unless $P10, rx284_fail
+    rx284_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("EXPR")
-    rx294_pos = $P10."pos"()
+    rx284_pos = $P10."pos"()
 .annotate 'line', 94
   # rx pass
-    rx294_cur."!cursor_pass"(rx294_pos, "metachar:sym<~>")
-    rx294_cur."!cursor_debug"("PASS  ", "metachar:sym<~>", " at pos=", rx294_pos)
-    .return (rx294_cur)
-  rx294_fail:
+    rx284_cur."!cursor_pass"(rx284_pos, "metachar:sym<~>")
+    rx284_cur."!cursor_debug"("PASS  ", "metachar:sym<~>", " at pos=", rx284_pos)
+    .return (rx284_cur)
+  rx284_restart:
 .annotate 'line', 3
-    (rx294_rep, rx294_pos, $I10, $P10) = rx294_cur."!mark_fail"(0)
-    lt rx294_pos, -1, rx294_done
-    eq rx294_pos, -1, rx294_fail
+    rx284_cur."!cursor_debug"("NEXT ", "metachar:sym<~>")
+  rx284_fail:
+    (rx284_rep, rx284_pos, $I10, $P10) = rx284_cur."!mark_fail"(0)
+    lt rx284_pos, -1, rx284_done
+    eq rx284_pos, -1, rx284_fail
     jump $I10
-  rx294_done:
-    rx294_cur."!cursor_fail"()
-    rx294_cur."!cursor_debug"("FAIL  ", "metachar:sym<~>")
-    .return (rx294_cur)
+  rx284_done:
+    rx284_cur."!cursor_fail"()
+    rx284_cur."!cursor_debug"("FAIL  ", "metachar:sym<~>")
+    .return (rx284_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<~>"  :subid("84_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<~>"  :subid("84_1279529218.55263") :method
 .annotate 'line', 3
-    $P296 = self."!PREFIX__!subrule"("ws", "~")
-    new $P297, "ResizablePMCArray"
-    push $P297, $P296
-    .return ($P297)
+    $P286 = self."!PREFIX__!subrule"("ws", "~")
+    new $P287, "ResizablePMCArray"
+    push $P287, $P286
+    .return ($P287)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<{*}>"  :subid("85_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<{*}>"  :subid("85_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx301_tgt
-    .local int rx301_pos
-    .local int rx301_off
-    .local int rx301_eos
-    .local int rx301_rep
-    .local pmc rx301_cur
-    (rx301_cur, rx301_pos, rx301_tgt) = self."!cursor_start"()
-    rx301_cur."!cursor_debug"("START ", "metachar:sym<{*}>")
-    rx301_cur."!cursor_caparray"("key")
-    .lex unicode:"$\x{a2}", rx301_cur
+    .local string rx291_tgt
+    .local int rx291_pos
+    .local int rx291_off
+    .local int rx291_eos
+    .local int rx291_rep
+    .local pmc rx291_cur
+    (rx291_cur, rx291_pos, rx291_tgt, $I10) = self."!cursor_start"()
+    rx291_cur."!cursor_caparray"("key")
+    .lex unicode:"$\x{a2}", rx291_cur
     .local pmc match
     .lex "$/", match
-    length rx301_eos, rx301_tgt
-    gt rx301_pos, rx301_eos, rx301_done
-    set rx301_off, 0
-    lt rx301_pos, 2, rx301_start
-    sub rx301_off, rx301_pos, 1
-    substr rx301_tgt, rx301_tgt, rx301_off
-  rx301_start:
+    length rx291_eos, rx291_tgt
+    gt rx291_pos, rx291_eos, rx291_done
+    set rx291_off, 0
+    lt rx291_pos, 2, rx291_start
+    sub rx291_off, rx291_pos, 1
+    substr rx291_tgt, rx291_tgt, rx291_off
+  rx291_start:
+    eq $I10, 1, rx291_restart
+    rx291_cur."!cursor_debug"("START ", "metachar:sym<{*}>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan304_done
-    goto rxscan304_scan
-  rxscan304_loop:
-    ($P10) = rx301_cur."from"()
+    ne $I10, -1, rxscan294_done
+    goto rxscan294_scan
+  rxscan294_loop:
+    ($P10) = rx291_cur."from"()
     inc $P10
-    set rx301_pos, $P10
-    ge rx301_pos, rx301_eos, rxscan304_done
-  rxscan304_scan:
-    set_addr $I10, rxscan304_loop
-    rx301_cur."!mark_push"(0, rx301_pos, $I10)
-  rxscan304_done:
+    set rx291_pos, $P10
+    ge rx291_pos, rx291_eos, rxscan294_done
+  rxscan294_scan:
+    set_addr $I10, rxscan294_loop
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  rxscan294_done:
 .annotate 'line', 101
   # rx subcapture "sym"
-    set_addr $I10, rxcap_305_fail
-    rx301_cur."!mark_push"(0, rx301_pos, $I10)
+    set_addr $I10, rxcap_295_fail
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
   # rx literal  "{*}"
-    add $I11, rx301_pos, 3
-    gt $I11, rx301_eos, rx301_fail
-    sub $I11, rx301_pos, rx301_off
-    substr $S10, rx301_tgt, $I11, 3
-    ne $S10, "{*}", rx301_fail
-    add rx301_pos, 3
-    set_addr $I10, rxcap_305_fail
-    ($I12, $I11) = rx301_cur."!mark_peek"($I10)
-    rx301_cur."!cursor_pos"($I11)
-    ($P10) = rx301_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx301_pos, "")
-    rx301_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx291_pos, 3
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 3
+    ne $S10, "{*}", rx291_fail
+    add rx291_pos, 3
+    set_addr $I10, rxcap_295_fail
+    ($I12, $I11) = rx291_cur."!mark_peek"($I10)
+    rx291_cur."!cursor_pos"($I11)
+    ($P10) = rx291_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx291_pos, "")
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_305_done
-  rxcap_305_fail:
-    goto rx301_fail
-  rxcap_305_done:
+    goto rxcap_295_done
+  rxcap_295_fail:
+    goto rx291_fail
+  rxcap_295_done:
 .annotate 'line', 102
-  # rx rxquantr306 ** 0..1
-    set_addr $I316, rxquantr306_done
-    rx301_cur."!mark_push"(0, rx301_pos, $I316)
-  rxquantr306_loop:
-  # rx rxquantr307 ** 0..*
-    set_addr $I308, rxquantr307_done
-    rx301_cur."!mark_push"(0, rx301_pos, $I308)
-  rxquantr307_loop:
+  # rx rxquantr296 ** 0..1
+    set_addr $I10, rxquantr296_done
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  rxquantr296_loop:
+  # rx rxquantr297 ** 0..*
+    set_addr $I10, rxquantr297_done
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  rxquantr297_loop:
   # rx enumcharlist negate=0 
-    ge rx301_pos, rx301_eos, rx301_fail
-    sub $I10, rx301_pos, rx301_off
-    substr $S10, rx301_tgt, $I10, 1
+    ge rx291_pos, rx291_eos, rx291_fail
+    sub $I10, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx301_fail
-    inc rx301_pos
-    (rx301_rep) = rx301_cur."!mark_commit"($I308)
-    rx301_cur."!mark_push"(rx301_rep, rx301_pos, $I308)
-    goto rxquantr307_loop
-  rxquantr307_done:
+    lt $I11, 0, rx291_fail
+    inc rx291_pos
+    set_addr $I10, rxquantr297_done
+    (rx291_rep) = rx291_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr297_done
+    rx291_cur."!mark_push"(rx291_rep, rx291_pos, $I10)
+    goto rxquantr297_loop
+  rxquantr297_done:
   # rx literal  "#= "
-    add $I11, rx301_pos, 3
-    gt $I11, rx301_eos, rx301_fail
-    sub $I11, rx301_pos, rx301_off
-    substr $S10, rx301_tgt, $I11, 3
-    ne $S10, "#= ", rx301_fail
-    add rx301_pos, 3
-  # rx rxquantr309 ** 0..*
-    set_addr $I310, rxquantr309_done
-    rx301_cur."!mark_push"(0, rx301_pos, $I310)
-  rxquantr309_loop:
+    add $I11, rx291_pos, 3
+    gt $I11, rx291_eos, rx291_fail
+    sub $I11, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I11, 3
+    ne $S10, "#= ", rx291_fail
+    add rx291_pos, 3
+  # rx rxquantr298 ** 0..*
+    set_addr $I10, rxquantr298_done
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  rxquantr298_loop:
   # rx enumcharlist negate=0 
-    ge rx301_pos, rx301_eos, rx301_fail
-    sub $I10, rx301_pos, rx301_off
-    substr $S10, rx301_tgt, $I10, 1
+    ge rx291_pos, rx291_eos, rx291_fail
+    sub $I10, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx301_fail
-    inc rx301_pos
-    (rx301_rep) = rx301_cur."!mark_commit"($I310)
-    rx301_cur."!mark_push"(rx301_rep, rx301_pos, $I310)
-    goto rxquantr309_loop
-  rxquantr309_done:
+    lt $I11, 0, rx291_fail
+    inc rx291_pos
+    set_addr $I10, rxquantr298_done
+    (rx291_rep) = rx291_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr298_done
+    rx291_cur."!mark_push"(rx291_rep, rx291_pos, $I10)
+    goto rxquantr298_loop
+  rxquantr298_done:
   # rx subcapture "key"
-    set_addr $I10, rxcap_315_fail
-    rx301_cur."!mark_push"(0, rx301_pos, $I10)
+    set_addr $I10, rxcap_301_fail
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
   # rx charclass_q S r 1..-1
-    sub $I10, rx301_pos, rx301_off
-    find_cclass $I11, 32, rx301_tgt, $I10, rx301_eos
+    sub $I10, rx291_pos, rx291_off
+    find_cclass $I11, 32, rx291_tgt, $I10, rx291_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx301_fail
-    add rx301_pos, rx301_off, $I11
-  # rx rxquantr311 ** 0..*
-    set_addr $I314, rxquantr311_done
-    rx301_cur."!mark_push"(0, rx301_pos, $I314)
-  rxquantr311_loop:
-  # rx rxquantr312 ** 1..*
-    set_addr $I313, rxquantr312_done
-    rx301_cur."!mark_push"(0, -1, $I313)
-  rxquantr312_loop:
+    lt $I11, $I12, rx291_fail
+    add rx291_pos, rx291_off, $I11
+  # rx rxquantr299 ** 0..*
+    set_addr $I10, rxquantr299_done
+    rx291_cur."!mark_push"(0, rx291_pos, $I10)
+  rxquantr299_loop:
+  # rx rxquantr300 ** 1..*
+    set_addr $I10, rxquantr300_done
+    rx291_cur."!mark_push"(0, -1, $I10)
+  rxquantr300_loop:
   # rx enumcharlist negate=0 
-    ge rx301_pos, rx301_eos, rx301_fail
-    sub $I10, rx301_pos, rx301_off
-    substr $S10, rx301_tgt, $I10, 1
+    ge rx291_pos, rx291_eos, rx291_fail
+    sub $I10, rx291_pos, rx291_off
+    substr $S10, rx291_tgt, $I10, 1
     index $I11, unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", $S10
-    lt $I11, 0, rx301_fail
-    inc rx301_pos
-    (rx301_rep) = rx301_cur."!mark_commit"($I313)
-    rx301_cur."!mark_push"(rx301_rep, rx301_pos, $I313)
-    goto rxquantr312_loop
-  rxquantr312_done:
+    lt $I11, 0, rx291_fail
+    inc rx291_pos
+    set_addr $I10, rxquantr300_done
+    (rx291_rep) = rx291_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr300_done
+    rx291_cur."!mark_push"(rx291_rep, rx291_pos, $I10)
+    goto rxquantr300_loop
+  rxquantr300_done:
   # rx charclass_q S r 1..-1
-    sub $I10, rx301_pos, rx301_off
-    find_cclass $I11, 32, rx301_tgt, $I10, rx301_eos
+    sub $I10, rx291_pos, rx291_off
+    find_cclass $I11, 32, rx291_tgt, $I10, rx291_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx301_fail
-    add rx301_pos, rx301_off, $I11
-    (rx301_rep) = rx301_cur."!mark_commit"($I314)
-    rx301_cur."!mark_push"(rx301_rep, rx301_pos, $I314)
-    goto rxquantr311_loop
-  rxquantr311_done:
-    set_addr $I10, rxcap_315_fail
-    ($I12, $I11) = rx301_cur."!mark_peek"($I10)
-    rx301_cur."!cursor_pos"($I11)
-    ($P10) = rx301_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx301_pos, "")
-    rx301_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx291_fail
+    add rx291_pos, rx291_off, $I11
+    set_addr $I10, rxquantr299_done
+    (rx291_rep) = rx291_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr299_done
+    rx291_cur."!mark_push"(rx291_rep, rx291_pos, $I10)
+    goto rxquantr299_loop
+  rxquantr299_done:
+    set_addr $I10, rxcap_301_fail
+    ($I12, $I11) = rx291_cur."!mark_peek"($I10)
+    rx291_cur."!cursor_pos"($I11)
+    ($P10) = rx291_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx291_pos, "")
+    rx291_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("key")
-    goto rxcap_315_done
-  rxcap_315_fail:
-    goto rx301_fail
-  rxcap_315_done:
-    (rx301_rep) = rx301_cur."!mark_commit"($I316)
-  rxquantr306_done:
+    goto rxcap_301_done
+  rxcap_301_fail:
+    goto rx291_fail
+  rxcap_301_done:
+    set_addr $I10, rxquantr296_done
+    (rx291_rep) = rx291_cur."!mark_commit"($I10)
+  rxquantr296_done:
 .annotate 'line', 100
   # rx pass
-    rx301_cur."!cursor_pass"(rx301_pos, "metachar:sym<{*}>")
-    rx301_cur."!cursor_debug"("PASS  ", "metachar:sym<{*}>", " at pos=", rx301_pos)
-    .return (rx301_cur)
-  rx301_fail:
+    rx291_cur."!cursor_pass"(rx291_pos, "metachar:sym<{*}>")
+    rx291_cur."!cursor_debug"("PASS  ", "metachar:sym<{*}>", " at pos=", rx291_pos)
+    .return (rx291_cur)
+  rx291_restart:
 .annotate 'line', 3
-    (rx301_rep, rx301_pos, $I10, $P10) = rx301_cur."!mark_fail"(0)
-    lt rx301_pos, -1, rx301_done
-    eq rx301_pos, -1, rx301_fail
+    rx291_cur."!cursor_debug"("NEXT ", "metachar:sym<{*}>")
+  rx291_fail:
+    (rx291_rep, rx291_pos, $I10, $P10) = rx291_cur."!mark_fail"(0)
+    lt rx291_pos, -1, rx291_done
+    eq rx291_pos, -1, rx291_fail
     jump $I10
-  rx301_done:
-    rx301_cur."!cursor_fail"()
-    rx301_cur."!cursor_debug"("FAIL  ", "metachar:sym<{*}>")
-    .return (rx301_cur)
+  rx291_done:
+    rx291_cur."!cursor_fail"()
+    rx291_cur."!cursor_debug"("FAIL  ", "metachar:sym<{*}>")
+    .return (rx291_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<{*}>"  :subid("86_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<{*}>"  :subid("86_1279529218.55263") :method
 .annotate 'line', 3
-    new $P303, "ResizablePMCArray"
-    push $P303, "{*}"
-    .return ($P303)
+    new $P293, "ResizablePMCArray"
+    push $P293, "{*}"
+    .return ($P293)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<assert>"  :subid("87_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<assert>"  :subid("87_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx318_tgt
-    .local int rx318_pos
-    .local int rx318_off
-    .local int rx318_eos
-    .local int rx318_rep
-    .local pmc rx318_cur
-    (rx318_cur, rx318_pos, rx318_tgt) = self."!cursor_start"()
-    rx318_cur."!cursor_debug"("START ", "metachar:sym<assert>")
-    .lex unicode:"$\x{a2}", rx318_cur
+    .local string rx303_tgt
+    .local int rx303_pos
+    .local int rx303_off
+    .local int rx303_eos
+    .local int rx303_rep
+    .local pmc rx303_cur
+    (rx303_cur, rx303_pos, rx303_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx303_cur
     .local pmc match
     .lex "$/", match
-    length rx318_eos, rx318_tgt
-    gt rx318_pos, rx318_eos, rx318_done
-    set rx318_off, 0
-    lt rx318_pos, 2, rx318_start
-    sub rx318_off, rx318_pos, 1
-    substr rx318_tgt, rx318_tgt, rx318_off
-  rx318_start:
+    length rx303_eos, rx303_tgt
+    gt rx303_pos, rx303_eos, rx303_done
+    set rx303_off, 0
+    lt rx303_pos, 2, rx303_start
+    sub rx303_off, rx303_pos, 1
+    substr rx303_tgt, rx303_tgt, rx303_off
+  rx303_start:
+    eq $I10, 1, rx303_restart
+    rx303_cur."!cursor_debug"("START ", "metachar:sym<assert>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan322_done
-    goto rxscan322_scan
-  rxscan322_loop:
-    ($P10) = rx318_cur."from"()
+    ne $I10, -1, rxscan307_done
+    goto rxscan307_scan
+  rxscan307_loop:
+    ($P10) = rx303_cur."from"()
     inc $P10
-    set rx318_pos, $P10
-    ge rx318_pos, rx318_eos, rxscan322_done
-  rxscan322_scan:
-    set_addr $I10, rxscan322_loop
-    rx318_cur."!mark_push"(0, rx318_pos, $I10)
-  rxscan322_done:
+    set rx303_pos, $P10
+    ge rx303_pos, rx303_eos, rxscan307_done
+  rxscan307_scan:
+    set_addr $I10, rxscan307_loop
+    rx303_cur."!mark_push"(0, rx303_pos, $I10)
+  rxscan307_done:
 .annotate 'line', 105
   # rx literal  "<"
-    add $I11, rx318_pos, 1
-    gt $I11, rx318_eos, rx318_fail
-    sub $I11, rx318_pos, rx318_off
-    substr $S10, rx318_tgt, $I11, 1
-    ne $S10, "<", rx318_fail
-    add rx318_pos, 1
+    add $I11, rx303_pos, 1
+    gt $I11, rx303_eos, rx303_fail
+    sub $I11, rx303_pos, rx303_off
+    substr $S10, rx303_tgt, $I11, 1
+    ne $S10, "<", rx303_fail
+    add rx303_pos, 1
   # rx subrule "assertion" subtype=capture negate=
-    rx318_cur."!cursor_pos"(rx318_pos)
-    $P10 = rx318_cur."assertion"()
-    unless $P10, rx318_fail
-    rx318_cur."!mark_push"(0, -1, 0, $P10)
+    rx303_cur."!cursor_pos"(rx303_pos)
+    $P10 = rx303_cur."assertion"()
+    unless $P10, rx303_fail
+    rx303_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("assertion")
-    rx318_pos = $P10."pos"()
-  alt323_0:
+    rx303_pos = $P10."pos"()
+  alt308_0:
 .annotate 'line', 106
-    set_addr $I10, alt323_1
-    rx318_cur."!mark_push"(0, rx318_pos, $I10)
+    set_addr $I10, alt308_1
+    rx303_cur."!mark_push"(0, rx303_pos, $I10)
   # rx literal  ">"
-    add $I11, rx318_pos, 1
-    gt $I11, rx318_eos, rx318_fail
-    sub $I11, rx318_pos, rx318_off
-    substr $S10, rx318_tgt, $I11, 1
-    ne $S10, ">", rx318_fail
-    add rx318_pos, 1
-    goto alt323_end
-  alt323_1:
+    add $I11, rx303_pos, 1
+    gt $I11, rx303_eos, rx303_fail
+    sub $I11, rx303_pos, rx303_off
+    substr $S10, rx303_tgt, $I11, 1
+    ne $S10, ">", rx303_fail
+    add rx303_pos, 1
+    goto alt308_end
+  alt308_1:
   # rx subrule "panic" subtype=method negate=
-    rx318_cur."!cursor_pos"(rx318_pos)
-    $P10 = rx318_cur."panic"("regex assertion not terminated by angle bracket")
-    unless $P10, rx318_fail
-    rx318_pos = $P10."pos"()
-  alt323_end:
+    rx303_cur."!cursor_pos"(rx303_pos)
+    $P10 = rx303_cur."panic"("regex assertion not terminated by angle bracket")
+    unless $P10, rx303_fail
+    rx303_pos = $P10."pos"()
+  alt308_end:
 .annotate 'line', 104
   # rx pass
-    rx318_cur."!cursor_pass"(rx318_pos, "metachar:sym<assert>")
-    rx318_cur."!cursor_debug"("PASS  ", "metachar:sym<assert>", " at pos=", rx318_pos)
-    .return (rx318_cur)
-  rx318_fail:
+    rx303_cur."!cursor_pass"(rx303_pos, "metachar:sym<assert>")
+    rx303_cur."!cursor_debug"("PASS  ", "metachar:sym<assert>", " at pos=", rx303_pos)
+    .return (rx303_cur)
+  rx303_restart:
 .annotate 'line', 3
-    (rx318_rep, rx318_pos, $I10, $P10) = rx318_cur."!mark_fail"(0)
-    lt rx318_pos, -1, rx318_done
-    eq rx318_pos, -1, rx318_fail
+    rx303_cur."!cursor_debug"("NEXT ", "metachar:sym<assert>")
+  rx303_fail:
+    (rx303_rep, rx303_pos, $I10, $P10) = rx303_cur."!mark_fail"(0)
+    lt rx303_pos, -1, rx303_done
+    eq rx303_pos, -1, rx303_fail
     jump $I10
-  rx318_done:
-    rx318_cur."!cursor_fail"()
-    rx318_cur."!cursor_debug"("FAIL  ", "metachar:sym<assert>")
-    .return (rx318_cur)
+  rx303_done:
+    rx303_cur."!cursor_fail"()
+    rx303_cur."!cursor_debug"("FAIL  ", "metachar:sym<assert>")
+    .return (rx303_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<assert>"  :subid("88_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<assert>"  :subid("88_1279529218.55263") :method
 .annotate 'line', 3
-    $P320 = self."!PREFIX__!subrule"("assertion", "<")
-    new $P321, "ResizablePMCArray"
-    push $P321, $P320
-    .return ($P321)
+    $P305 = self."!PREFIX__!subrule"("assertion", "<")
+    new $P306, "ResizablePMCArray"
+    push $P306, $P305
+    .return ($P306)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<var>"  :subid("89_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<var>"  :subid("89_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx325_tgt
-    .local int rx325_pos
-    .local int rx325_off
-    .local int rx325_eos
-    .local int rx325_rep
-    .local pmc rx325_cur
-    (rx325_cur, rx325_pos, rx325_tgt) = self."!cursor_start"()
-    rx325_cur."!cursor_debug"("START ", "metachar:sym<var>")
-    rx325_cur."!cursor_caparray"("quantified_atom")
-    .lex unicode:"$\x{a2}", rx325_cur
+    .local string rx310_tgt
+    .local int rx310_pos
+    .local int rx310_off
+    .local int rx310_eos
+    .local int rx310_rep
+    .local pmc rx310_cur
+    (rx310_cur, rx310_pos, rx310_tgt, $I10) = self."!cursor_start"()
+    rx310_cur."!cursor_caparray"("quantified_atom")
+    .lex unicode:"$\x{a2}", rx310_cur
     .local pmc match
     .lex "$/", match
-    length rx325_eos, rx325_tgt
-    gt rx325_pos, rx325_eos, rx325_done
-    set rx325_off, 0
-    lt rx325_pos, 2, rx325_start
-    sub rx325_off, rx325_pos, 1
-    substr rx325_tgt, rx325_tgt, rx325_off
-  rx325_start:
+    length rx310_eos, rx310_tgt
+    gt rx310_pos, rx310_eos, rx310_done
+    set rx310_off, 0
+    lt rx310_pos, 2, rx310_start
+    sub rx310_off, rx310_pos, 1
+    substr rx310_tgt, rx310_tgt, rx310_off
+  rx310_start:
+    eq $I10, 1, rx310_restart
+    rx310_cur."!cursor_debug"("START ", "metachar:sym<var>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan328_done
-    goto rxscan328_scan
-  rxscan328_loop:
-    ($P10) = rx325_cur."from"()
+    ne $I10, -1, rxscan313_done
+    goto rxscan313_scan
+  rxscan313_loop:
+    ($P10) = rx310_cur."from"()
     inc $P10
-    set rx325_pos, $P10
-    ge rx325_pos, rx325_eos, rxscan328_done
-  rxscan328_scan:
-    set_addr $I10, rxscan328_loop
-    rx325_cur."!mark_push"(0, rx325_pos, $I10)
-  rxscan328_done:
-  alt329_0:
+    set rx310_pos, $P10
+    ge rx310_pos, rx310_eos, rxscan313_done
+  rxscan313_scan:
+    set_addr $I10, rxscan313_loop
+    rx310_cur."!mark_push"(0, rx310_pos, $I10)
+  rxscan313_done:
+  alt314_0:
 .annotate 'line', 110
-    set_addr $I10, alt329_1
-    rx325_cur."!mark_push"(0, rx325_pos, $I10)
+    set_addr $I10, alt314_1
+    rx310_cur."!mark_push"(0, rx310_pos, $I10)
 .annotate 'line', 111
   # rx literal  "$<"
-    add $I11, rx325_pos, 2
-    gt $I11, rx325_eos, rx325_fail
-    sub $I11, rx325_pos, rx325_off
-    substr $S10, rx325_tgt, $I11, 2
-    ne $S10, "$<", rx325_fail
-    add rx325_pos, 2
+    add $I11, rx310_pos, 2
+    gt $I11, rx310_eos, rx310_fail
+    sub $I11, rx310_pos, rx310_off
+    substr $S10, rx310_tgt, $I11, 2
+    ne $S10, "$<", rx310_fail
+    add rx310_pos, 2
   # rx subcapture "name"
-    set_addr $I10, rxcap_332_fail
-    rx325_cur."!mark_push"(0, rx325_pos, $I10)
-  # rx rxquantr330 ** 1..*
-    set_addr $I331, rxquantr330_done
-    rx325_cur."!mark_push"(0, -1, $I331)
-  rxquantr330_loop:
+    set_addr $I10, rxcap_316_fail
+    rx310_cur."!mark_push"(0, rx310_pos, $I10)
+  # rx rxquantr315 ** 1..*
+    set_addr $I10, rxquantr315_done
+    rx310_cur."!mark_push"(0, -1, $I10)
+  rxquantr315_loop:
   # rx enumcharlist negate=1 
-    ge rx325_pos, rx325_eos, rx325_fail
-    sub $I10, rx325_pos, rx325_off
-    substr $S10, rx325_tgt, $I10, 1
+    ge rx310_pos, rx310_eos, rx310_fail
+    sub $I10, rx310_pos, rx310_off
+    substr $S10, rx310_tgt, $I10, 1
     index $I11, ">", $S10
-    ge $I11, 0, rx325_fail
-    inc rx325_pos
-    (rx325_rep) = rx325_cur."!mark_commit"($I331)
-    rx325_cur."!mark_push"(rx325_rep, rx325_pos, $I331)
-    goto rxquantr330_loop
-  rxquantr330_done:
-    set_addr $I10, rxcap_332_fail
-    ($I12, $I11) = rx325_cur."!mark_peek"($I10)
-    rx325_cur."!cursor_pos"($I11)
-    ($P10) = rx325_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx325_pos, "")
-    rx325_cur."!mark_push"(0, -1, 0, $P10)
+    ge $I11, 0, rx310_fail
+    inc rx310_pos
+    set_addr $I10, rxquantr315_done
+    (rx310_rep) = rx310_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr315_done
+    rx310_cur."!mark_push"(rx310_rep, rx310_pos, $I10)
+    goto rxquantr315_loop
+  rxquantr315_done:
+    set_addr $I10, rxcap_316_fail
+    ($I12, $I11) = rx310_cur."!mark_peek"($I10)
+    rx310_cur."!cursor_pos"($I11)
+    ($P10) = rx310_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx310_pos, "")
+    rx310_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("name")
-    goto rxcap_332_done
-  rxcap_332_fail:
-    goto rx325_fail
-  rxcap_332_done:
+    goto rxcap_316_done
+  rxcap_316_fail:
+    goto rx310_fail
+  rxcap_316_done:
   # rx literal  ">"
-    add $I11, rx325_pos, 1
-    gt $I11, rx325_eos, rx325_fail
-    sub $I11, rx325_pos, rx325_off
-    substr $S10, rx325_tgt, $I11, 1
-    ne $S10, ">", rx325_fail
-    add rx325_pos, 1
-    goto alt329_end
-  alt329_1:
+    add $I11, rx310_pos, 1
+    gt $I11, rx310_eos, rx310_fail
+    sub $I11, rx310_pos, rx310_off
+    substr $S10, rx310_tgt, $I11, 1
+    ne $S10, ">", rx310_fail
+    add rx310_pos, 1
+    goto alt314_end
+  alt314_1:
 .annotate 'line', 112
   # rx literal  "$"
-    add $I11, rx325_pos, 1
-    gt $I11, rx325_eos, rx325_fail
-    sub $I11, rx325_pos, rx325_off
-    substr $S10, rx325_tgt, $I11, 1
-    ne $S10, "$", rx325_fail
-    add rx325_pos, 1
+    add $I11, rx310_pos, 1
+    gt $I11, rx310_eos, rx310_fail
+    sub $I11, rx310_pos, rx310_off
+    substr $S10, rx310_tgt, $I11, 1
+    ne $S10, "$", rx310_fail
+    add rx310_pos, 1
   # rx subcapture "pos"
-    set_addr $I10, rxcap_333_fail
-    rx325_cur."!mark_push"(0, rx325_pos, $I10)
+    set_addr $I10, rxcap_317_fail
+    rx310_cur."!mark_push"(0, rx310_pos, $I10)
   # rx charclass_q d r 1..-1
-    sub $I10, rx325_pos, rx325_off
-    find_not_cclass $I11, 8, rx325_tgt, $I10, rx325_eos
+    sub $I10, rx310_pos, rx310_off
+    find_not_cclass $I11, 8, rx310_tgt, $I10, rx310_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx325_fail
-    add rx325_pos, rx325_off, $I11
-    set_addr $I10, rxcap_333_fail
-    ($I12, $I11) = rx325_cur."!mark_peek"($I10)
-    rx325_cur."!cursor_pos"($I11)
-    ($P10) = rx325_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx325_pos, "")
-    rx325_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx310_fail
+    add rx310_pos, rx310_off, $I11
+    set_addr $I10, rxcap_317_fail
+    ($I12, $I11) = rx310_cur."!mark_peek"($I10)
+    rx310_cur."!cursor_pos"($I11)
+    ($P10) = rx310_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx310_pos, "")
+    rx310_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("pos")
-    goto rxcap_333_done
-  rxcap_333_fail:
-    goto rx325_fail
-  rxcap_333_done:
-  alt329_end:
+    goto rxcap_317_done
+  rxcap_317_fail:
+    goto rx310_fail
+  rxcap_317_done:
+  alt314_end:
 .annotate 'line', 115
-  # rx rxquantr334 ** 0..1
-    set_addr $I335, rxquantr334_done
-    rx325_cur."!mark_push"(0, rx325_pos, $I335)
-  rxquantr334_loop:
+  # rx rxquantr318 ** 0..1
+    set_addr $I10, rxquantr318_done
+    rx310_cur."!mark_push"(0, rx310_pos, $I10)
+  rxquantr318_loop:
   # rx subrule "ws" subtype=method negate=
-    rx325_cur."!cursor_pos"(rx325_pos)
-    $P10 = rx325_cur."ws"()
-    unless $P10, rx325_fail
-    rx325_pos = $P10."pos"()
+    rx310_cur."!cursor_pos"(rx310_pos)
+    $P10 = rx310_cur."ws"()
+    unless $P10, rx310_fail
+    rx310_pos = $P10."pos"()
   # rx literal  "="
-    add $I11, rx325_pos, 1
-    gt $I11, rx325_eos, rx325_fail
-    sub $I11, rx325_pos, rx325_off
-    substr $S10, rx325_tgt, $I11, 1
-    ne $S10, "=", rx325_fail
-    add rx325_pos, 1
+    add $I11, rx310_pos, 1
+    gt $I11, rx310_eos, rx310_fail
+    sub $I11, rx310_pos, rx310_off
+    substr $S10, rx310_tgt, $I11, 1
+    ne $S10, "=", rx310_fail
+    add rx310_pos, 1
   # rx subrule "ws" subtype=method negate=
-    rx325_cur."!cursor_pos"(rx325_pos)
-    $P10 = rx325_cur."ws"()
-    unless $P10, rx325_fail
-    rx325_pos = $P10."pos"()
+    rx310_cur."!cursor_pos"(rx310_pos)
+    $P10 = rx310_cur."ws"()
+    unless $P10, rx310_fail
+    rx310_pos = $P10."pos"()
   # rx subrule "quantified_atom" subtype=capture negate=
-    rx325_cur."!cursor_pos"(rx325_pos)
-    $P10 = rx325_cur."quantified_atom"()
-    unless $P10, rx325_fail
-    rx325_cur."!mark_push"(0, -1, 0, $P10)
+    rx310_cur."!cursor_pos"(rx310_pos)
+    $P10 = rx310_cur."quantified_atom"()
+    unless $P10, rx310_fail
+    rx310_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("quantified_atom")
-    rx325_pos = $P10."pos"()
-    (rx325_rep) = rx325_cur."!mark_commit"($I335)
-  rxquantr334_done:
+    rx310_pos = $P10."pos"()
+    set_addr $I10, rxquantr318_done
+    (rx310_rep) = rx310_cur."!mark_commit"($I10)
+  rxquantr318_done:
 .annotate 'line', 109
   # rx pass
-    rx325_cur."!cursor_pass"(rx325_pos, "metachar:sym<var>")
-    rx325_cur."!cursor_debug"("PASS  ", "metachar:sym<var>", " at pos=", rx325_pos)
-    .return (rx325_cur)
-  rx325_fail:
+    rx310_cur."!cursor_pass"(rx310_pos, "metachar:sym<var>")
+    rx310_cur."!cursor_debug"("PASS  ", "metachar:sym<var>", " at pos=", rx310_pos)
+    .return (rx310_cur)
+  rx310_restart:
 .annotate 'line', 3
-    (rx325_rep, rx325_pos, $I10, $P10) = rx325_cur."!mark_fail"(0)
-    lt rx325_pos, -1, rx325_done
-    eq rx325_pos, -1, rx325_fail
+    rx310_cur."!cursor_debug"("NEXT ", "metachar:sym<var>")
+  rx310_fail:
+    (rx310_rep, rx310_pos, $I10, $P10) = rx310_cur."!mark_fail"(0)
+    lt rx310_pos, -1, rx310_done
+    eq rx310_pos, -1, rx310_fail
     jump $I10
-  rx325_done:
-    rx325_cur."!cursor_fail"()
-    rx325_cur."!cursor_debug"("FAIL  ", "metachar:sym<var>")
-    .return (rx325_cur)
+  rx310_done:
+    rx310_cur."!cursor_fail"()
+    rx310_cur."!cursor_debug"("FAIL  ", "metachar:sym<var>")
+    .return (rx310_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<var>"  :subid("90_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<var>"  :subid("90_1279529218.55263") :method
 .annotate 'line', 3
-    new $P327, "ResizablePMCArray"
-    push $P327, "$"
-    push $P327, "$<"
-    .return ($P327)
+    new $P312, "ResizablePMCArray"
+    push $P312, "$"
+    push $P312, "$<"
+    .return ($P312)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "metachar:sym<PIR>"  :subid("91_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "metachar:sym<PIR>"  :subid("91_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx337_tgt
-    .local int rx337_pos
-    .local int rx337_off
-    .local int rx337_eos
-    .local int rx337_rep
-    .local pmc rx337_cur
-    (rx337_cur, rx337_pos, rx337_tgt) = self."!cursor_start"()
-    rx337_cur."!cursor_debug"("START ", "metachar:sym<PIR>")
-    .lex unicode:"$\x{a2}", rx337_cur
+    .local string rx320_tgt
+    .local int rx320_pos
+    .local int rx320_off
+    .local int rx320_eos
+    .local int rx320_rep
+    .local pmc rx320_cur
+    (rx320_cur, rx320_pos, rx320_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx320_cur
     .local pmc match
     .lex "$/", match
-    length rx337_eos, rx337_tgt
-    gt rx337_pos, rx337_eos, rx337_done
-    set rx337_off, 0
-    lt rx337_pos, 2, rx337_start
-    sub rx337_off, rx337_pos, 1
-    substr rx337_tgt, rx337_tgt, rx337_off
-  rx337_start:
+    length rx320_eos, rx320_tgt
+    gt rx320_pos, rx320_eos, rx320_done
+    set rx320_off, 0
+    lt rx320_pos, 2, rx320_start
+    sub rx320_off, rx320_pos, 1
+    substr rx320_tgt, rx320_tgt, rx320_off
+  rx320_start:
+    eq $I10, 1, rx320_restart
+    rx320_cur."!cursor_debug"("START ", "metachar:sym<PIR>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan340_done
-    goto rxscan340_scan
-  rxscan340_loop:
-    ($P10) = rx337_cur."from"()
+    ne $I10, -1, rxscan323_done
+    goto rxscan323_scan
+  rxscan323_loop:
+    ($P10) = rx320_cur."from"()
     inc $P10
-    set rx337_pos, $P10
-    ge rx337_pos, rx337_eos, rxscan340_done
-  rxscan340_scan:
-    set_addr $I10, rxscan340_loop
-    rx337_cur."!mark_push"(0, rx337_pos, $I10)
-  rxscan340_done:
+    set rx320_pos, $P10
+    ge rx320_pos, rx320_eos, rxscan323_done
+  rxscan323_scan:
+    set_addr $I10, rxscan323_loop
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
+  rxscan323_done:
 .annotate 'line', 119
   # rx literal  ":PIR{{"
-    add $I11, rx337_pos, 6
-    gt $I11, rx337_eos, rx337_fail
-    sub $I11, rx337_pos, rx337_off
-    substr $S10, rx337_tgt, $I11, 6
-    ne $S10, ":PIR{{", rx337_fail
-    add rx337_pos, 6
+    add $I11, rx320_pos, 6
+    gt $I11, rx320_eos, rx320_fail
+    sub $I11, rx320_pos, rx320_off
+    substr $S10, rx320_tgt, $I11, 6
+    ne $S10, ":PIR{{", rx320_fail
+    add rx320_pos, 6
   # rx subcapture "pir"
-    set_addr $I10, rxcap_343_fail
-    rx337_cur."!mark_push"(0, rx337_pos, $I10)
-  # rx rxquantf341 ** 0..*
-    set_addr $I10, rxquantf341_loop
-    rx337_cur."!mark_push"(0, rx337_pos, $I10)
-    goto rxquantf341_done
-  rxquantf341_loop:
+    set_addr $I10, rxcap_326_fail
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
+  # rx rxquantf324 ** 0..*
+    set_addr $I10, rxquantf324_loop
+    rx320_cur."!mark_push"(0, rx320_pos, $I10)
+    goto rxquantf324_done
+  rxquantf324_loop:
   # rx charclass .
-    ge rx337_pos, rx337_eos, rx337_fail
-    inc rx337_pos
-    set_addr $I10, rxquantf341_loop
-    rx337_cur."!mark_push"($I342, rx337_pos, $I10)
-  rxquantf341_done:
-    set_addr $I10, rxcap_343_fail
-    ($I12, $I11) = rx337_cur."!mark_peek"($I10)
-    rx337_cur."!cursor_pos"($I11)
-    ($P10) = rx337_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx337_pos, "")
-    rx337_cur."!mark_push"(0, -1, 0, $P10)
+    ge rx320_pos, rx320_eos, rx320_fail
+    inc rx320_pos
+    set_addr $I10, rxquantf324_loop
+    rx320_cur."!mark_push"(rx320_rep, rx320_pos, $I10)
+  rxquantf324_done:
+    set_addr $I10, rxcap_326_fail
+    ($I12, $I11) = rx320_cur."!mark_peek"($I10)
+    rx320_cur."!cursor_pos"($I11)
+    ($P10) = rx320_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx320_pos, "")
+    rx320_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("pir")
-    goto rxcap_343_done
-  rxcap_343_fail:
-    goto rx337_fail
-  rxcap_343_done:
+    goto rxcap_326_done
+  rxcap_326_fail:
+    goto rx320_fail
+  rxcap_326_done:
   # rx literal  "}}"
-    add $I11, rx337_pos, 2
-    gt $I11, rx337_eos, rx337_fail
-    sub $I11, rx337_pos, rx337_off
-    substr $S10, rx337_tgt, $I11, 2
-    ne $S10, "}}", rx337_fail
-    add rx337_pos, 2
+    add $I11, rx320_pos, 2
+    gt $I11, rx320_eos, rx320_fail
+    sub $I11, rx320_pos, rx320_off
+    substr $S10, rx320_tgt, $I11, 2
+    ne $S10, "}}", rx320_fail
+    add rx320_pos, 2
 .annotate 'line', 118
   # rx pass
-    rx337_cur."!cursor_pass"(rx337_pos, "metachar:sym<PIR>")
-    rx337_cur."!cursor_debug"("PASS  ", "metachar:sym<PIR>", " at pos=", rx337_pos)
-    .return (rx337_cur)
-  rx337_fail:
+    rx320_cur."!cursor_pass"(rx320_pos, "metachar:sym<PIR>")
+    rx320_cur."!cursor_debug"("PASS  ", "metachar:sym<PIR>", " at pos=", rx320_pos)
+    .return (rx320_cur)
+  rx320_restart:
 .annotate 'line', 3
-    (rx337_rep, rx337_pos, $I10, $P10) = rx337_cur."!mark_fail"(0)
-    lt rx337_pos, -1, rx337_done
-    eq rx337_pos, -1, rx337_fail
+    rx320_cur."!cursor_debug"("NEXT ", "metachar:sym<PIR>")
+  rx320_fail:
+    (rx320_rep, rx320_pos, $I10, $P10) = rx320_cur."!mark_fail"(0)
+    lt rx320_pos, -1, rx320_done
+    eq rx320_pos, -1, rx320_fail
     jump $I10
-  rx337_done:
-    rx337_cur."!cursor_fail"()
-    rx337_cur."!cursor_debug"("FAIL  ", "metachar:sym<PIR>")
-    .return (rx337_cur)
+  rx320_done:
+    rx320_cur."!cursor_fail"()
+    rx320_cur."!cursor_debug"("FAIL  ", "metachar:sym<PIR>")
+    .return (rx320_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__metachar:sym<PIR>"  :subid("92_1278500530.77787") :method
+.sub "!PREFIX__metachar:sym<PIR>"  :subid("92_1279529218.55263") :method
 .annotate 'line', 3
-    new $P339, "ResizablePMCArray"
-    push $P339, ":PIR{{"
-    .return ($P339)
+    new $P322, "ResizablePMCArray"
+    push $P322, ":PIR{{"
+    .return ($P322)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash"  :subid("93_1278500530.77787") :method
+.sub "backslash"  :subid("93_1279529218.55263") :method
 .annotate 'line', 122
-    $P345 = self."!protoregex"("backslash")
-    .return ($P345)
+    $P328 = self."!protoregex"("backslash")
+    .return ($P328)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash"  :subid("94_1278500530.77787") :method
+.sub "!PREFIX__backslash"  :subid("94_1279529218.55263") :method
 .annotate 'line', 122
-    $P347 = self."!PREFIX__!protoregex"("backslash")
-    .return ($P347)
+    $P330 = self."!PREFIX__!protoregex"("backslash")
+    .return ($P330)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<w>"  :subid("95_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<w>"  :subid("95_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx349_tgt
-    .local int rx349_pos
-    .local int rx349_off
-    .local int rx349_eos
-    .local int rx349_rep
-    .local pmc rx349_cur
-    (rx349_cur, rx349_pos, rx349_tgt) = self."!cursor_start"()
-    rx349_cur."!cursor_debug"("START ", "backslash:sym<w>")
-    .lex unicode:"$\x{a2}", rx349_cur
-    .local pmc match
-    .lex "$/", match
-    length rx349_eos, rx349_tgt
-    gt rx349_pos, rx349_eos, rx349_done
-    set rx349_off, 0
-    lt rx349_pos, 2, rx349_start
-    sub rx349_off, rx349_pos, 1
-    substr rx349_tgt, rx349_tgt, rx349_off
-  rx349_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan352_done
-    goto rxscan352_scan
-  rxscan352_loop:
-    ($P10) = rx349_cur."from"()
-    inc $P10
-    set rx349_pos, $P10
-    ge rx349_pos, rx349_eos, rxscan352_done
-  rxscan352_scan:
-    set_addr $I10, rxscan352_loop
-    rx349_cur."!mark_push"(0, rx349_pos, $I10)
-  rxscan352_done:
+    .local string rx332_tgt
+    .local int rx332_pos
+    .local int rx332_off
+    .local int rx332_eos
+    .local int rx332_rep
+    .local pmc rx332_cur
+    (rx332_cur, rx332_pos, rx332_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx332_cur
+    .local pmc match
+    .lex "$/", match
+    length rx332_eos, rx332_tgt
+    gt rx332_pos, rx332_eos, rx332_done
+    set rx332_off, 0
+    lt rx332_pos, 2, rx332_start
+    sub rx332_off, rx332_pos, 1
+    substr rx332_tgt, rx332_tgt, rx332_off
+  rx332_start:
+    eq $I10, 1, rx332_restart
+    rx332_cur."!cursor_debug"("START ", "backslash:sym<w>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan335_done
+    goto rxscan335_scan
+  rxscan335_loop:
+    ($P10) = rx332_cur."from"()
+    inc $P10
+    set rx332_pos, $P10
+    ge rx332_pos, rx332_eos, rxscan335_done
+  rxscan335_scan:
+    set_addr $I10, rxscan335_loop
+    rx332_cur."!mark_push"(0, rx332_pos, $I10)
+  rxscan335_done:
 .annotate 'line', 123
   # rx subcapture "sym"
-    set_addr $I10, rxcap_353_fail
-    rx349_cur."!mark_push"(0, rx349_pos, $I10)
+    set_addr $I10, rxcap_336_fail
+    rx332_cur."!mark_push"(0, rx332_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx349_pos, rx349_eos, rx349_fail
-    sub $I10, rx349_pos, rx349_off
-    substr $S10, rx349_tgt, $I10, 1
+    ge rx332_pos, rx332_eos, rx332_fail
+    sub $I10, rx332_pos, rx332_off
+    substr $S10, rx332_tgt, $I10, 1
     index $I11, "dswnDSWN", $S10
-    lt $I11, 0, rx349_fail
-    inc rx349_pos
-    set_addr $I10, rxcap_353_fail
-    ($I12, $I11) = rx349_cur."!mark_peek"($I10)
-    rx349_cur."!cursor_pos"($I11)
-    ($P10) = rx349_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx349_pos, "")
-    rx349_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx332_fail
+    inc rx332_pos
+    set_addr $I10, rxcap_336_fail
+    ($I12, $I11) = rx332_cur."!mark_peek"($I10)
+    rx332_cur."!cursor_pos"($I11)
+    ($P10) = rx332_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx332_pos, "")
+    rx332_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_353_done
-  rxcap_353_fail:
-    goto rx349_fail
-  rxcap_353_done:
-  # rx pass
-    rx349_cur."!cursor_pass"(rx349_pos, "backslash:sym<w>")
-    rx349_cur."!cursor_debug"("PASS  ", "backslash:sym<w>", " at pos=", rx349_pos)
-    .return (rx349_cur)
-  rx349_fail:
-.annotate 'line', 3
-    (rx349_rep, rx349_pos, $I10, $P10) = rx349_cur."!mark_fail"(0)
-    lt rx349_pos, -1, rx349_done
-    eq rx349_pos, -1, rx349_fail
-    jump $I10
-  rx349_done:
-    rx349_cur."!cursor_fail"()
-    rx349_cur."!cursor_debug"("FAIL  ", "backslash:sym<w>")
-    .return (rx349_cur)
+    goto rxcap_336_done
+  rxcap_336_fail:
+    goto rx332_fail
+  rxcap_336_done:
+  # rx pass
+    rx332_cur."!cursor_pass"(rx332_pos, "backslash:sym<w>")
+    rx332_cur."!cursor_debug"("PASS  ", "backslash:sym<w>", " at pos=", rx332_pos)
+    .return (rx332_cur)
+  rx332_restart:
+.annotate 'line', 3
+    rx332_cur."!cursor_debug"("NEXT ", "backslash:sym<w>")
+  rx332_fail:
+    (rx332_rep, rx332_pos, $I10, $P10) = rx332_cur."!mark_fail"(0)
+    lt rx332_pos, -1, rx332_done
+    eq rx332_pos, -1, rx332_fail
+    jump $I10
+  rx332_done:
+    rx332_cur."!cursor_fail"()
+    rx332_cur."!cursor_debug"("FAIL  ", "backslash:sym<w>")
+    .return (rx332_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<w>"  :subid("96_1278500530.77787") :method
-.annotate 'line', 3
-    new $P351, "ResizablePMCArray"
-    push $P351, "N"
-    push $P351, "W"
-    push $P351, "S"
-    push $P351, "D"
-    push $P351, "n"
-    push $P351, "w"
-    push $P351, "s"
-    push $P351, "d"
-    .return ($P351)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<b>"  :subid("97_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx355_tgt
-    .local int rx355_pos
-    .local int rx355_off
-    .local int rx355_eos
-    .local int rx355_rep
-    .local pmc rx355_cur
-    (rx355_cur, rx355_pos, rx355_tgt) = self."!cursor_start"()
-    rx355_cur."!cursor_debug"("START ", "backslash:sym<b>")
-    .lex unicode:"$\x{a2}", rx355_cur
-    .local pmc match
-    .lex "$/", match
-    length rx355_eos, rx355_tgt
-    gt rx355_pos, rx355_eos, rx355_done
-    set rx355_off, 0
-    lt rx355_pos, 2, rx355_start
-    sub rx355_off, rx355_pos, 1
-    substr rx355_tgt, rx355_tgt, rx355_off
-  rx355_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan358_done
-    goto rxscan358_scan
-  rxscan358_loop:
-    ($P10) = rx355_cur."from"()
-    inc $P10
-    set rx355_pos, $P10
-    ge rx355_pos, rx355_eos, rxscan358_done
-  rxscan358_scan:
-    set_addr $I10, rxscan358_loop
-    rx355_cur."!mark_push"(0, rx355_pos, $I10)
-  rxscan358_done:
+.sub "!PREFIX__backslash:sym<w>"  :subid("96_1279529218.55263") :method
+.annotate 'line', 3
+    new $P334, "ResizablePMCArray"
+    push $P334, "N"
+    push $P334, "W"
+    push $P334, "S"
+    push $P334, "D"
+    push $P334, "n"
+    push $P334, "w"
+    push $P334, "s"
+    push $P334, "d"
+    .return ($P334)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "backslash:sym<b>"  :subid("97_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx338_tgt
+    .local int rx338_pos
+    .local int rx338_off
+    .local int rx338_eos
+    .local int rx338_rep
+    .local pmc rx338_cur
+    (rx338_cur, rx338_pos, rx338_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx338_cur
+    .local pmc match
+    .lex "$/", match
+    length rx338_eos, rx338_tgt
+    gt rx338_pos, rx338_eos, rx338_done
+    set rx338_off, 0
+    lt rx338_pos, 2, rx338_start
+    sub rx338_off, rx338_pos, 1
+    substr rx338_tgt, rx338_tgt, rx338_off
+  rx338_start:
+    eq $I10, 1, rx338_restart
+    rx338_cur."!cursor_debug"("START ", "backslash:sym<b>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan341_done
+    goto rxscan341_scan
+  rxscan341_loop:
+    ($P10) = rx338_cur."from"()
+    inc $P10
+    set rx338_pos, $P10
+    ge rx338_pos, rx338_eos, rxscan341_done
+  rxscan341_scan:
+    set_addr $I10, rxscan341_loop
+    rx338_cur."!mark_push"(0, rx338_pos, $I10)
+  rxscan341_done:
 .annotate 'line', 124
   # rx subcapture "sym"
-    set_addr $I10, rxcap_359_fail
-    rx355_cur."!mark_push"(0, rx355_pos, $I10)
+    set_addr $I10, rxcap_342_fail
+    rx338_cur."!mark_push"(0, rx338_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx355_pos, rx355_eos, rx355_fail
-    sub $I10, rx355_pos, rx355_off
-    substr $S10, rx355_tgt, $I10, 1
+    ge rx338_pos, rx338_eos, rx338_fail
+    sub $I10, rx338_pos, rx338_off
+    substr $S10, rx338_tgt, $I10, 1
     index $I11, "bB", $S10
-    lt $I11, 0, rx355_fail
-    inc rx355_pos
-    set_addr $I10, rxcap_359_fail
-    ($I12, $I11) = rx355_cur."!mark_peek"($I10)
-    rx355_cur."!cursor_pos"($I11)
-    ($P10) = rx355_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx355_pos, "")
-    rx355_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx338_fail
+    inc rx338_pos
+    set_addr $I10, rxcap_342_fail
+    ($I12, $I11) = rx338_cur."!mark_peek"($I10)
+    rx338_cur."!cursor_pos"($I11)
+    ($P10) = rx338_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx338_pos, "")
+    rx338_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_359_done
-  rxcap_359_fail:
-    goto rx355_fail
-  rxcap_359_done:
+    goto rxcap_342_done
+  rxcap_342_fail:
+    goto rx338_fail
+  rxcap_342_done:
   # rx pass
-    rx355_cur."!cursor_pass"(rx355_pos, "backslash:sym<b>")
-    rx355_cur."!cursor_debug"("PASS  ", "backslash:sym<b>", " at pos=", rx355_pos)
-    .return (rx355_cur)
-  rx355_fail:
+    rx338_cur."!cursor_pass"(rx338_pos, "backslash:sym<b>")
+    rx338_cur."!cursor_debug"("PASS  ", "backslash:sym<b>", " at pos=", rx338_pos)
+    .return (rx338_cur)
+  rx338_restart:
 .annotate 'line', 3
-    (rx355_rep, rx355_pos, $I10, $P10) = rx355_cur."!mark_fail"(0)
-    lt rx355_pos, -1, rx355_done
-    eq rx355_pos, -1, rx355_fail
+    rx338_cur."!cursor_debug"("NEXT ", "backslash:sym<b>")
+  rx338_fail:
+    (rx338_rep, rx338_pos, $I10, $P10) = rx338_cur."!mark_fail"(0)
+    lt rx338_pos, -1, rx338_done
+    eq rx338_pos, -1, rx338_fail
     jump $I10
-  rx355_done:
-    rx355_cur."!cursor_fail"()
-    rx355_cur."!cursor_debug"("FAIL  ", "backslash:sym<b>")
-    .return (rx355_cur)
+  rx338_done:
+    rx338_cur."!cursor_fail"()
+    rx338_cur."!cursor_debug"("FAIL  ", "backslash:sym<b>")
+    .return (rx338_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<b>"  :subid("98_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<b>"  :subid("98_1279529218.55263") :method
 .annotate 'line', 3
-    new $P357, "ResizablePMCArray"
-    push $P357, "B"
-    push $P357, "b"
-    .return ($P357)
+    new $P340, "ResizablePMCArray"
+    push $P340, "B"
+    push $P340, "b"
+    .return ($P340)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<e>"  :subid("99_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<e>"  :subid("99_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx361_tgt
-    .local int rx361_pos
-    .local int rx361_off
-    .local int rx361_eos
-    .local int rx361_rep
-    .local pmc rx361_cur
-    (rx361_cur, rx361_pos, rx361_tgt) = self."!cursor_start"()
-    rx361_cur."!cursor_debug"("START ", "backslash:sym<e>")
-    .lex unicode:"$\x{a2}", rx361_cur
+    .local string rx344_tgt
+    .local int rx344_pos
+    .local int rx344_off
+    .local int rx344_eos
+    .local int rx344_rep
+    .local pmc rx344_cur
+    (rx344_cur, rx344_pos, rx344_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx344_cur
     .local pmc match
     .lex "$/", match
-    length rx361_eos, rx361_tgt
-    gt rx361_pos, rx361_eos, rx361_done
-    set rx361_off, 0
-    lt rx361_pos, 2, rx361_start
-    sub rx361_off, rx361_pos, 1
-    substr rx361_tgt, rx361_tgt, rx361_off
-  rx361_start:
+    length rx344_eos, rx344_tgt
+    gt rx344_pos, rx344_eos, rx344_done
+    set rx344_off, 0
+    lt rx344_pos, 2, rx344_start
+    sub rx344_off, rx344_pos, 1
+    substr rx344_tgt, rx344_tgt, rx344_off
+  rx344_start:
+    eq $I10, 1, rx344_restart
+    rx344_cur."!cursor_debug"("START ", "backslash:sym<e>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan364_done
-    goto rxscan364_scan
-  rxscan364_loop:
-    ($P10) = rx361_cur."from"()
+    ne $I10, -1, rxscan347_done
+    goto rxscan347_scan
+  rxscan347_loop:
+    ($P10) = rx344_cur."from"()
     inc $P10
-    set rx361_pos, $P10
-    ge rx361_pos, rx361_eos, rxscan364_done
-  rxscan364_scan:
-    set_addr $I10, rxscan364_loop
-    rx361_cur."!mark_push"(0, rx361_pos, $I10)
-  rxscan364_done:
+    set rx344_pos, $P10
+    ge rx344_pos, rx344_eos, rxscan347_done
+  rxscan347_scan:
+    set_addr $I10, rxscan347_loop
+    rx344_cur."!mark_push"(0, rx344_pos, $I10)
+  rxscan347_done:
 .annotate 'line', 125
   # rx subcapture "sym"
-    set_addr $I10, rxcap_365_fail
-    rx361_cur."!mark_push"(0, rx361_pos, $I10)
+    set_addr $I10, rxcap_348_fail
+    rx344_cur."!mark_push"(0, rx344_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx361_pos, rx361_eos, rx361_fail
-    sub $I10, rx361_pos, rx361_off
-    substr $S10, rx361_tgt, $I10, 1
+    ge rx344_pos, rx344_eos, rx344_fail
+    sub $I10, rx344_pos, rx344_off
+    substr $S10, rx344_tgt, $I10, 1
     index $I11, "eE", $S10
-    lt $I11, 0, rx361_fail
-    inc rx361_pos
-    set_addr $I10, rxcap_365_fail
-    ($I12, $I11) = rx361_cur."!mark_peek"($I10)
-    rx361_cur."!cursor_pos"($I11)
-    ($P10) = rx361_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx361_pos, "")
-    rx361_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx344_fail
+    inc rx344_pos
+    set_addr $I10, rxcap_348_fail
+    ($I12, $I11) = rx344_cur."!mark_peek"($I10)
+    rx344_cur."!cursor_pos"($I11)
+    ($P10) = rx344_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx344_pos, "")
+    rx344_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_365_done
-  rxcap_365_fail:
-    goto rx361_fail
-  rxcap_365_done:
+    goto rxcap_348_done
+  rxcap_348_fail:
+    goto rx344_fail
+  rxcap_348_done:
   # rx pass
-    rx361_cur."!cursor_pass"(rx361_pos, "backslash:sym<e>")
-    rx361_cur."!cursor_debug"("PASS  ", "backslash:sym<e>", " at pos=", rx361_pos)
-    .return (rx361_cur)
-  rx361_fail:
+    rx344_cur."!cursor_pass"(rx344_pos, "backslash:sym<e>")
+    rx344_cur."!cursor_debug"("PASS  ", "backslash:sym<e>", " at pos=", rx344_pos)
+    .return (rx344_cur)
+  rx344_restart:
 .annotate 'line', 3
-    (rx361_rep, rx361_pos, $I10, $P10) = rx361_cur."!mark_fail"(0)
-    lt rx361_pos, -1, rx361_done
-    eq rx361_pos, -1, rx361_fail
+    rx344_cur."!cursor_debug"("NEXT ", "backslash:sym<e>")
+  rx344_fail:
+    (rx344_rep, rx344_pos, $I10, $P10) = rx344_cur."!mark_fail"(0)
+    lt rx344_pos, -1, rx344_done
+    eq rx344_pos, -1, rx344_fail
     jump $I10
-  rx361_done:
-    rx361_cur."!cursor_fail"()
-    rx361_cur."!cursor_debug"("FAIL  ", "backslash:sym<e>")
-    .return (rx361_cur)
+  rx344_done:
+    rx344_cur."!cursor_fail"()
+    rx344_cur."!cursor_debug"("FAIL  ", "backslash:sym<e>")
+    .return (rx344_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<e>"  :subid("100_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<e>"  :subid("100_1279529218.55263") :method
 .annotate 'line', 3
-    new $P363, "ResizablePMCArray"
-    push $P363, "E"
-    push $P363, "e"
-    .return ($P363)
+    new $P346, "ResizablePMCArray"
+    push $P346, "E"
+    push $P346, "e"
+    .return ($P346)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<f>"  :subid("101_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<f>"  :subid("101_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx367_tgt
-    .local int rx367_pos
-    .local int rx367_off
-    .local int rx367_eos
-    .local int rx367_rep
-    .local pmc rx367_cur
-    (rx367_cur, rx367_pos, rx367_tgt) = self."!cursor_start"()
-    rx367_cur."!cursor_debug"("START ", "backslash:sym<f>")
-    .lex unicode:"$\x{a2}", rx367_cur
+    .local string rx350_tgt
+    .local int rx350_pos
+    .local int rx350_off
+    .local int rx350_eos
+    .local int rx350_rep
+    .local pmc rx350_cur
+    (rx350_cur, rx350_pos, rx350_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx350_cur
     .local pmc match
     .lex "$/", match
-    length rx367_eos, rx367_tgt
-    gt rx367_pos, rx367_eos, rx367_done
-    set rx367_off, 0
-    lt rx367_pos, 2, rx367_start
-    sub rx367_off, rx367_pos, 1
-    substr rx367_tgt, rx367_tgt, rx367_off
-  rx367_start:
+    length rx350_eos, rx350_tgt
+    gt rx350_pos, rx350_eos, rx350_done
+    set rx350_off, 0
+    lt rx350_pos, 2, rx350_start
+    sub rx350_off, rx350_pos, 1
+    substr rx350_tgt, rx350_tgt, rx350_off
+  rx350_start:
+    eq $I10, 1, rx350_restart
+    rx350_cur."!cursor_debug"("START ", "backslash:sym<f>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan370_done
-    goto rxscan370_scan
-  rxscan370_loop:
-    ($P10) = rx367_cur."from"()
+    ne $I10, -1, rxscan353_done
+    goto rxscan353_scan
+  rxscan353_loop:
+    ($P10) = rx350_cur."from"()
     inc $P10
-    set rx367_pos, $P10
-    ge rx367_pos, rx367_eos, rxscan370_done
-  rxscan370_scan:
-    set_addr $I10, rxscan370_loop
-    rx367_cur."!mark_push"(0, rx367_pos, $I10)
-  rxscan370_done:
+    set rx350_pos, $P10
+    ge rx350_pos, rx350_eos, rxscan353_done
+  rxscan353_scan:
+    set_addr $I10, rxscan353_loop
+    rx350_cur."!mark_push"(0, rx350_pos, $I10)
+  rxscan353_done:
 .annotate 'line', 126
   # rx subcapture "sym"
-    set_addr $I10, rxcap_371_fail
-    rx367_cur."!mark_push"(0, rx367_pos, $I10)
+    set_addr $I10, rxcap_354_fail
+    rx350_cur."!mark_push"(0, rx350_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx367_pos, rx367_eos, rx367_fail
-    sub $I10, rx367_pos, rx367_off
-    substr $S10, rx367_tgt, $I10, 1
+    ge rx350_pos, rx350_eos, rx350_fail
+    sub $I10, rx350_pos, rx350_off
+    substr $S10, rx350_tgt, $I10, 1
     index $I11, "fF", $S10
-    lt $I11, 0, rx367_fail
-    inc rx367_pos
-    set_addr $I10, rxcap_371_fail
-    ($I12, $I11) = rx367_cur."!mark_peek"($I10)
-    rx367_cur."!cursor_pos"($I11)
-    ($P10) = rx367_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx367_pos, "")
-    rx367_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx350_fail
+    inc rx350_pos
+    set_addr $I10, rxcap_354_fail
+    ($I12, $I11) = rx350_cur."!mark_peek"($I10)
+    rx350_cur."!cursor_pos"($I11)
+    ($P10) = rx350_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx350_pos, "")
+    rx350_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_371_done
-  rxcap_371_fail:
-    goto rx367_fail
-  rxcap_371_done:
+    goto rxcap_354_done
+  rxcap_354_fail:
+    goto rx350_fail
+  rxcap_354_done:
   # rx pass
-    rx367_cur."!cursor_pass"(rx367_pos, "backslash:sym<f>")
-    rx367_cur."!cursor_debug"("PASS  ", "backslash:sym<f>", " at pos=", rx367_pos)
-    .return (rx367_cur)
-  rx367_fail:
+    rx350_cur."!cursor_pass"(rx350_pos, "backslash:sym<f>")
+    rx350_cur."!cursor_debug"("PASS  ", "backslash:sym<f>", " at pos=", rx350_pos)
+    .return (rx350_cur)
+  rx350_restart:
 .annotate 'line', 3
-    (rx367_rep, rx367_pos, $I10, $P10) = rx367_cur."!mark_fail"(0)
-    lt rx367_pos, -1, rx367_done
-    eq rx367_pos, -1, rx367_fail
+    rx350_cur."!cursor_debug"("NEXT ", "backslash:sym<f>")
+  rx350_fail:
+    (rx350_rep, rx350_pos, $I10, $P10) = rx350_cur."!mark_fail"(0)
+    lt rx350_pos, -1, rx350_done
+    eq rx350_pos, -1, rx350_fail
     jump $I10
-  rx367_done:
-    rx367_cur."!cursor_fail"()
-    rx367_cur."!cursor_debug"("FAIL  ", "backslash:sym<f>")
-    .return (rx367_cur)
+  rx350_done:
+    rx350_cur."!cursor_fail"()
+    rx350_cur."!cursor_debug"("FAIL  ", "backslash:sym<f>")
+    .return (rx350_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<f>"  :subid("102_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<f>"  :subid("102_1279529218.55263") :method
 .annotate 'line', 3
-    new $P369, "ResizablePMCArray"
-    push $P369, "F"
-    push $P369, "f"
-    .return ($P369)
+    new $P352, "ResizablePMCArray"
+    push $P352, "F"
+    push $P352, "f"
+    .return ($P352)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<h>"  :subid("103_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<h>"  :subid("103_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx373_tgt
-    .local int rx373_pos
-    .local int rx373_off
-    .local int rx373_eos
-    .local int rx373_rep
-    .local pmc rx373_cur
-    (rx373_cur, rx373_pos, rx373_tgt) = self."!cursor_start"()
-    rx373_cur."!cursor_debug"("START ", "backslash:sym<h>")
-    .lex unicode:"$\x{a2}", rx373_cur
+    .local string rx356_tgt
+    .local int rx356_pos
+    .local int rx356_off
+    .local int rx356_eos
+    .local int rx356_rep
+    .local pmc rx356_cur
+    (rx356_cur, rx356_pos, rx356_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx356_cur
     .local pmc match
     .lex "$/", match
-    length rx373_eos, rx373_tgt
-    gt rx373_pos, rx373_eos, rx373_done
-    set rx373_off, 0
-    lt rx373_pos, 2, rx373_start
-    sub rx373_off, rx373_pos, 1
-    substr rx373_tgt, rx373_tgt, rx373_off
-  rx373_start:
+    length rx356_eos, rx356_tgt
+    gt rx356_pos, rx356_eos, rx356_done
+    set rx356_off, 0
+    lt rx356_pos, 2, rx356_start
+    sub rx356_off, rx356_pos, 1
+    substr rx356_tgt, rx356_tgt, rx356_off
+  rx356_start:
+    eq $I10, 1, rx356_restart
+    rx356_cur."!cursor_debug"("START ", "backslash:sym<h>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan376_done
-    goto rxscan376_scan
-  rxscan376_loop:
-    ($P10) = rx373_cur."from"()
+    ne $I10, -1, rxscan359_done
+    goto rxscan359_scan
+  rxscan359_loop:
+    ($P10) = rx356_cur."from"()
     inc $P10
-    set rx373_pos, $P10
-    ge rx373_pos, rx373_eos, rxscan376_done
-  rxscan376_scan:
-    set_addr $I10, rxscan376_loop
-    rx373_cur."!mark_push"(0, rx373_pos, $I10)
-  rxscan376_done:
+    set rx356_pos, $P10
+    ge rx356_pos, rx356_eos, rxscan359_done
+  rxscan359_scan:
+    set_addr $I10, rxscan359_loop
+    rx356_cur."!mark_push"(0, rx356_pos, $I10)
+  rxscan359_done:
 .annotate 'line', 127
   # rx subcapture "sym"
-    set_addr $I10, rxcap_377_fail
-    rx373_cur."!mark_push"(0, rx373_pos, $I10)
+    set_addr $I10, rxcap_360_fail
+    rx356_cur."!mark_push"(0, rx356_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx373_pos, rx373_eos, rx373_fail
-    sub $I10, rx373_pos, rx373_off
-    substr $S10, rx373_tgt, $I10, 1
+    ge rx356_pos, rx356_eos, rx356_fail
+    sub $I10, rx356_pos, rx356_off
+    substr $S10, rx356_tgt, $I10, 1
     index $I11, "hH", $S10
-    lt $I11, 0, rx373_fail
-    inc rx373_pos
-    set_addr $I10, rxcap_377_fail
-    ($I12, $I11) = rx373_cur."!mark_peek"($I10)
-    rx373_cur."!cursor_pos"($I11)
-    ($P10) = rx373_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx373_pos, "")
-    rx373_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx356_fail
+    inc rx356_pos
+    set_addr $I10, rxcap_360_fail
+    ($I12, $I11) = rx356_cur."!mark_peek"($I10)
+    rx356_cur."!cursor_pos"($I11)
+    ($P10) = rx356_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx356_pos, "")
+    rx356_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_377_done
-  rxcap_377_fail:
-    goto rx373_fail
-  rxcap_377_done:
+    goto rxcap_360_done
+  rxcap_360_fail:
+    goto rx356_fail
+  rxcap_360_done:
   # rx pass
-    rx373_cur."!cursor_pass"(rx373_pos, "backslash:sym<h>")
-    rx373_cur."!cursor_debug"("PASS  ", "backslash:sym<h>", " at pos=", rx373_pos)
-    .return (rx373_cur)
-  rx373_fail:
+    rx356_cur."!cursor_pass"(rx356_pos, "backslash:sym<h>")
+    rx356_cur."!cursor_debug"("PASS  ", "backslash:sym<h>", " at pos=", rx356_pos)
+    .return (rx356_cur)
+  rx356_restart:
 .annotate 'line', 3
-    (rx373_rep, rx373_pos, $I10, $P10) = rx373_cur."!mark_fail"(0)
-    lt rx373_pos, -1, rx373_done
-    eq rx373_pos, -1, rx373_fail
+    rx356_cur."!cursor_debug"("NEXT ", "backslash:sym<h>")
+  rx356_fail:
+    (rx356_rep, rx356_pos, $I10, $P10) = rx356_cur."!mark_fail"(0)
+    lt rx356_pos, -1, rx356_done
+    eq rx356_pos, -1, rx356_fail
     jump $I10
-  rx373_done:
-    rx373_cur."!cursor_fail"()
-    rx373_cur."!cursor_debug"("FAIL  ", "backslash:sym<h>")
-    .return (rx373_cur)
+  rx356_done:
+    rx356_cur."!cursor_fail"()
+    rx356_cur."!cursor_debug"("FAIL  ", "backslash:sym<h>")
+    .return (rx356_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<h>"  :subid("104_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<h>"  :subid("104_1279529218.55263") :method
 .annotate 'line', 3
-    new $P375, "ResizablePMCArray"
-    push $P375, "H"
-    push $P375, "h"
-    .return ($P375)
+    new $P358, "ResizablePMCArray"
+    push $P358, "H"
+    push $P358, "h"
+    .return ($P358)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<r>"  :subid("105_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<r>"  :subid("105_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx379_tgt
-    .local int rx379_pos
-    .local int rx379_off
-    .local int rx379_eos
-    .local int rx379_rep
-    .local pmc rx379_cur
-    (rx379_cur, rx379_pos, rx379_tgt) = self."!cursor_start"()
-    rx379_cur."!cursor_debug"("START ", "backslash:sym<r>")
-    .lex unicode:"$\x{a2}", rx379_cur
+    .local string rx362_tgt
+    .local int rx362_pos
+    .local int rx362_off
+    .local int rx362_eos
+    .local int rx362_rep
+    .local pmc rx362_cur
+    (rx362_cur, rx362_pos, rx362_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx362_cur
     .local pmc match
     .lex "$/", match
-    length rx379_eos, rx379_tgt
-    gt rx379_pos, rx379_eos, rx379_done
-    set rx379_off, 0
-    lt rx379_pos, 2, rx379_start
-    sub rx379_off, rx379_pos, 1
-    substr rx379_tgt, rx379_tgt, rx379_off
-  rx379_start:
+    length rx362_eos, rx362_tgt
+    gt rx362_pos, rx362_eos, rx362_done
+    set rx362_off, 0
+    lt rx362_pos, 2, rx362_start
+    sub rx362_off, rx362_pos, 1
+    substr rx362_tgt, rx362_tgt, rx362_off
+  rx362_start:
+    eq $I10, 1, rx362_restart
+    rx362_cur."!cursor_debug"("START ", "backslash:sym<r>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan382_done
-    goto rxscan382_scan
-  rxscan382_loop:
-    ($P10) = rx379_cur."from"()
+    ne $I10, -1, rxscan365_done
+    goto rxscan365_scan
+  rxscan365_loop:
+    ($P10) = rx362_cur."from"()
     inc $P10
-    set rx379_pos, $P10
-    ge rx379_pos, rx379_eos, rxscan382_done
-  rxscan382_scan:
-    set_addr $I10, rxscan382_loop
-    rx379_cur."!mark_push"(0, rx379_pos, $I10)
-  rxscan382_done:
+    set rx362_pos, $P10
+    ge rx362_pos, rx362_eos, rxscan365_done
+  rxscan365_scan:
+    set_addr $I10, rxscan365_loop
+    rx362_cur."!mark_push"(0, rx362_pos, $I10)
+  rxscan365_done:
 .annotate 'line', 128
   # rx subcapture "sym"
-    set_addr $I10, rxcap_383_fail
-    rx379_cur."!mark_push"(0, rx379_pos, $I10)
+    set_addr $I10, rxcap_366_fail
+    rx362_cur."!mark_push"(0, rx362_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx379_pos, rx379_eos, rx379_fail
-    sub $I10, rx379_pos, rx379_off
-    substr $S10, rx379_tgt, $I10, 1
+    ge rx362_pos, rx362_eos, rx362_fail
+    sub $I10, rx362_pos, rx362_off
+    substr $S10, rx362_tgt, $I10, 1
     index $I11, "rR", $S10
-    lt $I11, 0, rx379_fail
-    inc rx379_pos
-    set_addr $I10, rxcap_383_fail
-    ($I12, $I11) = rx379_cur."!mark_peek"($I10)
-    rx379_cur."!cursor_pos"($I11)
-    ($P10) = rx379_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx379_pos, "")
-    rx379_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx362_fail
+    inc rx362_pos
+    set_addr $I10, rxcap_366_fail
+    ($I12, $I11) = rx362_cur."!mark_peek"($I10)
+    rx362_cur."!cursor_pos"($I11)
+    ($P10) = rx362_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx362_pos, "")
+    rx362_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_383_done
-  rxcap_383_fail:
-    goto rx379_fail
-  rxcap_383_done:
+    goto rxcap_366_done
+  rxcap_366_fail:
+    goto rx362_fail
+  rxcap_366_done:
   # rx pass
-    rx379_cur."!cursor_pass"(rx379_pos, "backslash:sym<r>")
-    rx379_cur."!cursor_debug"("PASS  ", "backslash:sym<r>", " at pos=", rx379_pos)
-    .return (rx379_cur)
-  rx379_fail:
+    rx362_cur."!cursor_pass"(rx362_pos, "backslash:sym<r>")
+    rx362_cur."!cursor_debug"("PASS  ", "backslash:sym<r>", " at pos=", rx362_pos)
+    .return (rx362_cur)
+  rx362_restart:
 .annotate 'line', 3
-    (rx379_rep, rx379_pos, $I10, $P10) = rx379_cur."!mark_fail"(0)
-    lt rx379_pos, -1, rx379_done
-    eq rx379_pos, -1, rx379_fail
+    rx362_cur."!cursor_debug"("NEXT ", "backslash:sym<r>")
+  rx362_fail:
+    (rx362_rep, rx362_pos, $I10, $P10) = rx362_cur."!mark_fail"(0)
+    lt rx362_pos, -1, rx362_done
+    eq rx362_pos, -1, rx362_fail
     jump $I10
-  rx379_done:
-    rx379_cur."!cursor_fail"()
-    rx379_cur."!cursor_debug"("FAIL  ", "backslash:sym<r>")
-    .return (rx379_cur)
+  rx362_done:
+    rx362_cur."!cursor_fail"()
+    rx362_cur."!cursor_debug"("FAIL  ", "backslash:sym<r>")
+    .return (rx362_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<r>"  :subid("106_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<r>"  :subid("106_1279529218.55263") :method
 .annotate 'line', 3
-    new $P381, "ResizablePMCArray"
-    push $P381, "R"
-    push $P381, "r"
-    .return ($P381)
+    new $P364, "ResizablePMCArray"
+    push $P364, "R"
+    push $P364, "r"
+    .return ($P364)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<t>"  :subid("107_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<t>"  :subid("107_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx385_tgt
-    .local int rx385_pos
-    .local int rx385_off
-    .local int rx385_eos
-    .local int rx385_rep
-    .local pmc rx385_cur
-    (rx385_cur, rx385_pos, rx385_tgt) = self."!cursor_start"()
-    rx385_cur."!cursor_debug"("START ", "backslash:sym<t>")
-    .lex unicode:"$\x{a2}", rx385_cur
-    .local pmc match
-    .lex "$/", match
-    length rx385_eos, rx385_tgt
-    gt rx385_pos, rx385_eos, rx385_done
-    set rx385_off, 0
-    lt rx385_pos, 2, rx385_start
-    sub rx385_off, rx385_pos, 1
-    substr rx385_tgt, rx385_tgt, rx385_off
-  rx385_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan388_done
-    goto rxscan388_scan
-  rxscan388_loop:
-    ($P10) = rx385_cur."from"()
-    inc $P10
-    set rx385_pos, $P10
-    ge rx385_pos, rx385_eos, rxscan388_done
-  rxscan388_scan:
-    set_addr $I10, rxscan388_loop
-    rx385_cur."!mark_push"(0, rx385_pos, $I10)
-  rxscan388_done:
+    .local string rx368_tgt
+    .local int rx368_pos
+    .local int rx368_off
+    .local int rx368_eos
+    .local int rx368_rep
+    .local pmc rx368_cur
+    (rx368_cur, rx368_pos, rx368_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx368_cur
+    .local pmc match
+    .lex "$/", match
+    length rx368_eos, rx368_tgt
+    gt rx368_pos, rx368_eos, rx368_done
+    set rx368_off, 0
+    lt rx368_pos, 2, rx368_start
+    sub rx368_off, rx368_pos, 1
+    substr rx368_tgt, rx368_tgt, rx368_off
+  rx368_start:
+    eq $I10, 1, rx368_restart
+    rx368_cur."!cursor_debug"("START ", "backslash:sym<t>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan371_done
+    goto rxscan371_scan
+  rxscan371_loop:
+    ($P10) = rx368_cur."from"()
+    inc $P10
+    set rx368_pos, $P10
+    ge rx368_pos, rx368_eos, rxscan371_done
+  rxscan371_scan:
+    set_addr $I10, rxscan371_loop
+    rx368_cur."!mark_push"(0, rx368_pos, $I10)
+  rxscan371_done:
 .annotate 'line', 129
   # rx subcapture "sym"
-    set_addr $I10, rxcap_389_fail
-    rx385_cur."!mark_push"(0, rx385_pos, $I10)
+    set_addr $I10, rxcap_372_fail
+    rx368_cur."!mark_push"(0, rx368_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx385_pos, rx385_eos, rx385_fail
-    sub $I10, rx385_pos, rx385_off
-    substr $S10, rx385_tgt, $I10, 1
+    ge rx368_pos, rx368_eos, rx368_fail
+    sub $I10, rx368_pos, rx368_off
+    substr $S10, rx368_tgt, $I10, 1
     index $I11, "tT", $S10
-    lt $I11, 0, rx385_fail
-    inc rx385_pos
-    set_addr $I10, rxcap_389_fail
-    ($I12, $I11) = rx385_cur."!mark_peek"($I10)
-    rx385_cur."!cursor_pos"($I11)
-    ($P10) = rx385_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx385_pos, "")
-    rx385_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx368_fail
+    inc rx368_pos
+    set_addr $I10, rxcap_372_fail
+    ($I12, $I11) = rx368_cur."!mark_peek"($I10)
+    rx368_cur."!cursor_pos"($I11)
+    ($P10) = rx368_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx368_pos, "")
+    rx368_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_389_done
-  rxcap_389_fail:
-    goto rx385_fail
-  rxcap_389_done:
+    goto rxcap_372_done
+  rxcap_372_fail:
+    goto rx368_fail
+  rxcap_372_done:
   # rx pass
-    rx385_cur."!cursor_pass"(rx385_pos, "backslash:sym<t>")
-    rx385_cur."!cursor_debug"("PASS  ", "backslash:sym<t>", " at pos=", rx385_pos)
-    .return (rx385_cur)
-  rx385_fail:
+    rx368_cur."!cursor_pass"(rx368_pos, "backslash:sym<t>")
+    rx368_cur."!cursor_debug"("PASS  ", "backslash:sym<t>", " at pos=", rx368_pos)
+    .return (rx368_cur)
+  rx368_restart:
 .annotate 'line', 3
-    (rx385_rep, rx385_pos, $I10, $P10) = rx385_cur."!mark_fail"(0)
-    lt rx385_pos, -1, rx385_done
-    eq rx385_pos, -1, rx385_fail
+    rx368_cur."!cursor_debug"("NEXT ", "backslash:sym<t>")
+  rx368_fail:
+    (rx368_rep, rx368_pos, $I10, $P10) = rx368_cur."!mark_fail"(0)
+    lt rx368_pos, -1, rx368_done
+    eq rx368_pos, -1, rx368_fail
     jump $I10
-  rx385_done:
-    rx385_cur."!cursor_fail"()
-    rx385_cur."!cursor_debug"("FAIL  ", "backslash:sym<t>")
-    .return (rx385_cur)
+  rx368_done:
+    rx368_cur."!cursor_fail"()
+    rx368_cur."!cursor_debug"("FAIL  ", "backslash:sym<t>")
+    .return (rx368_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<t>"  :subid("108_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<t>"  :subid("108_1279529218.55263") :method
 .annotate 'line', 3
-    new $P387, "ResizablePMCArray"
-    push $P387, "T"
-    push $P387, "t"
-    .return ($P387)
+    new $P370, "ResizablePMCArray"
+    push $P370, "T"
+    push $P370, "t"
+    .return ($P370)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<v>"  :subid("109_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<v>"  :subid("109_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx391_tgt
-    .local int rx391_pos
-    .local int rx391_off
-    .local int rx391_eos
-    .local int rx391_rep
-    .local pmc rx391_cur
-    (rx391_cur, rx391_pos, rx391_tgt) = self."!cursor_start"()
-    rx391_cur."!cursor_debug"("START ", "backslash:sym<v>")
-    .lex unicode:"$\x{a2}", rx391_cur
+    .local string rx374_tgt
+    .local int rx374_pos
+    .local int rx374_off
+    .local int rx374_eos
+    .local int rx374_rep
+    .local pmc rx374_cur
+    (rx374_cur, rx374_pos, rx374_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx374_cur
     .local pmc match
     .lex "$/", match
-    length rx391_eos, rx391_tgt
-    gt rx391_pos, rx391_eos, rx391_done
-    set rx391_off, 0
-    lt rx391_pos, 2, rx391_start
-    sub rx391_off, rx391_pos, 1
-    substr rx391_tgt, rx391_tgt, rx391_off
-  rx391_start:
+    length rx374_eos, rx374_tgt
+    gt rx374_pos, rx374_eos, rx374_done
+    set rx374_off, 0
+    lt rx374_pos, 2, rx374_start
+    sub rx374_off, rx374_pos, 1
+    substr rx374_tgt, rx374_tgt, rx374_off
+  rx374_start:
+    eq $I10, 1, rx374_restart
+    rx374_cur."!cursor_debug"("START ", "backslash:sym<v>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan394_done
-    goto rxscan394_scan
-  rxscan394_loop:
-    ($P10) = rx391_cur."from"()
+    ne $I10, -1, rxscan377_done
+    goto rxscan377_scan
+  rxscan377_loop:
+    ($P10) = rx374_cur."from"()
     inc $P10
-    set rx391_pos, $P10
-    ge rx391_pos, rx391_eos, rxscan394_done
-  rxscan394_scan:
-    set_addr $I10, rxscan394_loop
-    rx391_cur."!mark_push"(0, rx391_pos, $I10)
-  rxscan394_done:
+    set rx374_pos, $P10
+    ge rx374_pos, rx374_eos, rxscan377_done
+  rxscan377_scan:
+    set_addr $I10, rxscan377_loop
+    rx374_cur."!mark_push"(0, rx374_pos, $I10)
+  rxscan377_done:
 .annotate 'line', 130
   # rx subcapture "sym"
-    set_addr $I10, rxcap_395_fail
-    rx391_cur."!mark_push"(0, rx391_pos, $I10)
+    set_addr $I10, rxcap_378_fail
+    rx374_cur."!mark_push"(0, rx374_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx391_pos, rx391_eos, rx391_fail
-    sub $I10, rx391_pos, rx391_off
-    substr $S10, rx391_tgt, $I10, 1
+    ge rx374_pos, rx374_eos, rx374_fail
+    sub $I10, rx374_pos, rx374_off
+    substr $S10, rx374_tgt, $I10, 1
     index $I11, "vV", $S10
-    lt $I11, 0, rx391_fail
-    inc rx391_pos
-    set_addr $I10, rxcap_395_fail
-    ($I12, $I11) = rx391_cur."!mark_peek"($I10)
-    rx391_cur."!cursor_pos"($I11)
-    ($P10) = rx391_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx391_pos, "")
-    rx391_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx374_fail
+    inc rx374_pos
+    set_addr $I10, rxcap_378_fail
+    ($I12, $I11) = rx374_cur."!mark_peek"($I10)
+    rx374_cur."!cursor_pos"($I11)
+    ($P10) = rx374_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx374_pos, "")
+    rx374_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_395_done
-  rxcap_395_fail:
-    goto rx391_fail
-  rxcap_395_done:
+    goto rxcap_378_done
+  rxcap_378_fail:
+    goto rx374_fail
+  rxcap_378_done:
   # rx pass
-    rx391_cur."!cursor_pass"(rx391_pos, "backslash:sym<v>")
-    rx391_cur."!cursor_debug"("PASS  ", "backslash:sym<v>", " at pos=", rx391_pos)
-    .return (rx391_cur)
-  rx391_fail:
+    rx374_cur."!cursor_pass"(rx374_pos, "backslash:sym<v>")
+    rx374_cur."!cursor_debug"("PASS  ", "backslash:sym<v>", " at pos=", rx374_pos)
+    .return (rx374_cur)
+  rx374_restart:
 .annotate 'line', 3
-    (rx391_rep, rx391_pos, $I10, $P10) = rx391_cur."!mark_fail"(0)
-    lt rx391_pos, -1, rx391_done
-    eq rx391_pos, -1, rx391_fail
+    rx374_cur."!cursor_debug"("NEXT ", "backslash:sym<v>")
+  rx374_fail:
+    (rx374_rep, rx374_pos, $I10, $P10) = rx374_cur."!mark_fail"(0)
+    lt rx374_pos, -1, rx374_done
+    eq rx374_pos, -1, rx374_fail
     jump $I10
-  rx391_done:
-    rx391_cur."!cursor_fail"()
-    rx391_cur."!cursor_debug"("FAIL  ", "backslash:sym<v>")
-    .return (rx391_cur)
+  rx374_done:
+    rx374_cur."!cursor_fail"()
+    rx374_cur."!cursor_debug"("FAIL  ", "backslash:sym<v>")
+    .return (rx374_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<v>"  :subid("110_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<v>"  :subid("110_1279529218.55263") :method
 .annotate 'line', 3
-    new $P393, "ResizablePMCArray"
-    push $P393, "V"
-    push $P393, "v"
-    .return ($P393)
+    new $P376, "ResizablePMCArray"
+    push $P376, "V"
+    push $P376, "v"
+    .return ($P376)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<o>"  :subid("111_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx397_tgt
-    .local int rx397_pos
-    .local int rx397_off
-    .local int rx397_eos
-    .local int rx397_rep
-    .local pmc rx397_cur
-    (rx397_cur, rx397_pos, rx397_tgt) = self."!cursor_start"()
-    rx397_cur."!cursor_debug"("START ", "backslash:sym<o>")
-    .lex unicode:"$\x{a2}", rx397_cur
-    .local pmc match
-    .lex "$/", match
-    length rx397_eos, rx397_tgt
-    gt rx397_pos, rx397_eos, rx397_done
-    set rx397_off, 0
-    lt rx397_pos, 2, rx397_start
-    sub rx397_off, rx397_pos, 1
-    substr rx397_tgt, rx397_tgt, rx397_off
-  rx397_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan404_done
-    goto rxscan404_scan
-  rxscan404_loop:
-    ($P10) = rx397_cur."from"()
-    inc $P10
-    set rx397_pos, $P10
-    ge rx397_pos, rx397_eos, rxscan404_done
-  rxscan404_scan:
-    set_addr $I10, rxscan404_loop
-    rx397_cur."!mark_push"(0, rx397_pos, $I10)
-  rxscan404_done:
+.sub "backslash:sym<o>"  :subid("111_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx380_tgt
+    .local int rx380_pos
+    .local int rx380_off
+    .local int rx380_eos
+    .local int rx380_rep
+    .local pmc rx380_cur
+    (rx380_cur, rx380_pos, rx380_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx380_cur
+    .local pmc match
+    .lex "$/", match
+    length rx380_eos, rx380_tgt
+    gt rx380_pos, rx380_eos, rx380_done
+    set rx380_off, 0
+    lt rx380_pos, 2, rx380_start
+    sub rx380_off, rx380_pos, 1
+    substr rx380_tgt, rx380_tgt, rx380_off
+  rx380_start:
+    eq $I10, 1, rx380_restart
+    rx380_cur."!cursor_debug"("START ", "backslash:sym<o>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan387_done
+    goto rxscan387_scan
+  rxscan387_loop:
+    ($P10) = rx380_cur."from"()
+    inc $P10
+    set rx380_pos, $P10
+    ge rx380_pos, rx380_eos, rxscan387_done
+  rxscan387_scan:
+    set_addr $I10, rxscan387_loop
+    rx380_cur."!mark_push"(0, rx380_pos, $I10)
+  rxscan387_done:
 .annotate 'line', 131
   # rx subcapture "sym"
-    set_addr $I10, rxcap_405_fail
-    rx397_cur."!mark_push"(0, rx397_pos, $I10)
+    set_addr $I10, rxcap_388_fail
+    rx380_cur."!mark_push"(0, rx380_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx397_pos, rx397_eos, rx397_fail
-    sub $I10, rx397_pos, rx397_off
-    substr $S10, rx397_tgt, $I10, 1
+    ge rx380_pos, rx380_eos, rx380_fail
+    sub $I10, rx380_pos, rx380_off
+    substr $S10, rx380_tgt, $I10, 1
     index $I11, "oO", $S10
-    lt $I11, 0, rx397_fail
-    inc rx397_pos
-    set_addr $I10, rxcap_405_fail
-    ($I12, $I11) = rx397_cur."!mark_peek"($I10)
-    rx397_cur."!cursor_pos"($I11)
-    ($P10) = rx397_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx397_pos, "")
-    rx397_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx380_fail
+    inc rx380_pos
+    set_addr $I10, rxcap_388_fail
+    ($I12, $I11) = rx380_cur."!mark_peek"($I10)
+    rx380_cur."!cursor_pos"($I11)
+    ($P10) = rx380_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx380_pos, "")
+    rx380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_405_done
-  rxcap_405_fail:
-    goto rx397_fail
-  rxcap_405_done:
-  alt406_0:
-    set_addr $I10, alt406_1
-    rx397_cur."!mark_push"(0, rx397_pos, $I10)
+    goto rxcap_388_done
+  rxcap_388_fail:
+    goto rx380_fail
+  rxcap_388_done:
+  alt389_0:
+    set_addr $I10, alt389_1
+    rx380_cur."!mark_push"(0, rx380_pos, $I10)
   # rx subrule "octint" subtype=capture negate=
-    rx397_cur."!cursor_pos"(rx397_pos)
-    $P10 = rx397_cur."octint"()
-    unless $P10, rx397_fail
-    rx397_cur."!mark_push"(0, -1, 0, $P10)
+    rx380_cur."!cursor_pos"(rx380_pos)
+    $P10 = rx380_cur."octint"()
+    unless $P10, rx380_fail
+    rx380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("octint")
-    rx397_pos = $P10."pos"()
-    goto alt406_end
-  alt406_1:
+    rx380_pos = $P10."pos"()
+    goto alt389_end
+  alt389_1:
   # rx literal  "["
-    add $I11, rx397_pos, 1
-    gt $I11, rx397_eos, rx397_fail
-    sub $I11, rx397_pos, rx397_off
-    substr $S10, rx397_tgt, $I11, 1
-    ne $S10, "[", rx397_fail
-    add rx397_pos, 1
+    add $I11, rx380_pos, 1
+    gt $I11, rx380_eos, rx380_fail
+    sub $I11, rx380_pos, rx380_off
+    substr $S10, rx380_tgt, $I11, 1
+    ne $S10, "[", rx380_fail
+    add rx380_pos, 1
   # rx subrule "octints" subtype=capture negate=
-    rx397_cur."!cursor_pos"(rx397_pos)
-    $P10 = rx397_cur."octints"()
-    unless $P10, rx397_fail
-    rx397_cur."!mark_push"(0, -1, 0, $P10)
+    rx380_cur."!cursor_pos"(rx380_pos)
+    $P10 = rx380_cur."octints"()
+    unless $P10, rx380_fail
+    rx380_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("octints")
-    rx397_pos = $P10."pos"()
+    rx380_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx397_pos, 1
-    gt $I11, rx397_eos, rx397_fail
-    sub $I11, rx397_pos, rx397_off
-    substr $S10, rx397_tgt, $I11, 1
-    ne $S10, "]", rx397_fail
-    add rx397_pos, 1
-  alt406_end:
-  # rx pass
-    rx397_cur."!cursor_pass"(rx397_pos, "backslash:sym<o>")
-    rx397_cur."!cursor_debug"("PASS  ", "backslash:sym<o>", " at pos=", rx397_pos)
-    .return (rx397_cur)
-  rx397_fail:
-.annotate 'line', 3
-    (rx397_rep, rx397_pos, $I10, $P10) = rx397_cur."!mark_fail"(0)
-    lt rx397_pos, -1, rx397_done
-    eq rx397_pos, -1, rx397_fail
-    jump $I10
-  rx397_done:
-    rx397_cur."!cursor_fail"()
-    rx397_cur."!cursor_debug"("FAIL  ", "backslash:sym<o>")
-    .return (rx397_cur)
+    add $I11, rx380_pos, 1
+    gt $I11, rx380_eos, rx380_fail
+    sub $I11, rx380_pos, rx380_off
+    substr $S10, rx380_tgt, $I11, 1
+    ne $S10, "]", rx380_fail
+    add rx380_pos, 1
+  alt389_end:
+  # rx pass
+    rx380_cur."!cursor_pass"(rx380_pos, "backslash:sym<o>")
+    rx380_cur."!cursor_debug"("PASS  ", "backslash:sym<o>", " at pos=", rx380_pos)
+    .return (rx380_cur)
+  rx380_restart:
+.annotate 'line', 3
+    rx380_cur."!cursor_debug"("NEXT ", "backslash:sym<o>")
+  rx380_fail:
+    (rx380_rep, rx380_pos, $I10, $P10) = rx380_cur."!mark_fail"(0)
+    lt rx380_pos, -1, rx380_done
+    eq rx380_pos, -1, rx380_fail
+    jump $I10
+  rx380_done:
+    rx380_cur."!cursor_fail"()
+    rx380_cur."!cursor_debug"("FAIL  ", "backslash:sym<o>")
+    .return (rx380_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<o>"  :subid("112_1278500530.77787") :method
-.annotate 'line', 3
-    $P399 = self."!PREFIX__!subrule"("octints", "O[")
-    $P400 = self."!PREFIX__!subrule"("octint", "O")
-    $P401 = self."!PREFIX__!subrule"("octints", "o[")
-    $P402 = self."!PREFIX__!subrule"("octint", "o")
-    new $P403, "ResizablePMCArray"
-    push $P403, $P399
-    push $P403, $P400
-    push $P403, $P401
-    push $P403, $P402
-    .return ($P403)
+.sub "!PREFIX__backslash:sym<o>"  :subid("112_1279529218.55263") :method
+.annotate 'line', 3
+    $P382 = self."!PREFIX__!subrule"("octints", "O[")
+    $P383 = self."!PREFIX__!subrule"("octint", "O")
+    $P384 = self."!PREFIX__!subrule"("octints", "o[")
+    $P385 = self."!PREFIX__!subrule"("octint", "o")
+    new $P386, "ResizablePMCArray"
+    push $P386, $P382
+    push $P386, $P383
+    push $P386, $P384
+    push $P386, $P385
+    .return ($P386)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<x>"  :subid("113_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<x>"  :subid("113_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx408_tgt
-    .local int rx408_pos
-    .local int rx408_off
-    .local int rx408_eos
-    .local int rx408_rep
-    .local pmc rx408_cur
-    (rx408_cur, rx408_pos, rx408_tgt) = self."!cursor_start"()
-    rx408_cur."!cursor_debug"("START ", "backslash:sym<x>")
-    .lex unicode:"$\x{a2}", rx408_cur
-    .local pmc match
-    .lex "$/", match
-    length rx408_eos, rx408_tgt
-    gt rx408_pos, rx408_eos, rx408_done
-    set rx408_off, 0
-    lt rx408_pos, 2, rx408_start
-    sub rx408_off, rx408_pos, 1
-    substr rx408_tgt, rx408_tgt, rx408_off
-  rx408_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan415_done
-    goto rxscan415_scan
-  rxscan415_loop:
-    ($P10) = rx408_cur."from"()
-    inc $P10
-    set rx408_pos, $P10
-    ge rx408_pos, rx408_eos, rxscan415_done
-  rxscan415_scan:
-    set_addr $I10, rxscan415_loop
-    rx408_cur."!mark_push"(0, rx408_pos, $I10)
-  rxscan415_done:
+    .local string rx391_tgt
+    .local int rx391_pos
+    .local int rx391_off
+    .local int rx391_eos
+    .local int rx391_rep
+    .local pmc rx391_cur
+    (rx391_cur, rx391_pos, rx391_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx391_cur
+    .local pmc match
+    .lex "$/", match
+    length rx391_eos, rx391_tgt
+    gt rx391_pos, rx391_eos, rx391_done
+    set rx391_off, 0
+    lt rx391_pos, 2, rx391_start
+    sub rx391_off, rx391_pos, 1
+    substr rx391_tgt, rx391_tgt, rx391_off
+  rx391_start:
+    eq $I10, 1, rx391_restart
+    rx391_cur."!cursor_debug"("START ", "backslash:sym<x>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan398_done
+    goto rxscan398_scan
+  rxscan398_loop:
+    ($P10) = rx391_cur."from"()
+    inc $P10
+    set rx391_pos, $P10
+    ge rx391_pos, rx391_eos, rxscan398_done
+  rxscan398_scan:
+    set_addr $I10, rxscan398_loop
+    rx391_cur."!mark_push"(0, rx391_pos, $I10)
+  rxscan398_done:
 .annotate 'line', 132
   # rx subcapture "sym"
-    set_addr $I10, rxcap_416_fail
-    rx408_cur."!mark_push"(0, rx408_pos, $I10)
+    set_addr $I10, rxcap_399_fail
+    rx391_cur."!mark_push"(0, rx391_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx408_pos, rx408_eos, rx408_fail
-    sub $I10, rx408_pos, rx408_off
-    substr $S10, rx408_tgt, $I10, 1
+    ge rx391_pos, rx391_eos, rx391_fail
+    sub $I10, rx391_pos, rx391_off
+    substr $S10, rx391_tgt, $I10, 1
     index $I11, "xX", $S10
-    lt $I11, 0, rx408_fail
-    inc rx408_pos
-    set_addr $I10, rxcap_416_fail
-    ($I12, $I11) = rx408_cur."!mark_peek"($I10)
-    rx408_cur."!cursor_pos"($I11)
-    ($P10) = rx408_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx408_pos, "")
-    rx408_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx391_fail
+    inc rx391_pos
+    set_addr $I10, rxcap_399_fail
+    ($I12, $I11) = rx391_cur."!mark_peek"($I10)
+    rx391_cur."!cursor_pos"($I11)
+    ($P10) = rx391_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx391_pos, "")
+    rx391_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_416_done
-  rxcap_416_fail:
-    goto rx408_fail
-  rxcap_416_done:
-  alt417_0:
-    set_addr $I10, alt417_1
-    rx408_cur."!mark_push"(0, rx408_pos, $I10)
+    goto rxcap_399_done
+  rxcap_399_fail:
+    goto rx391_fail
+  rxcap_399_done:
+  alt400_0:
+    set_addr $I10, alt400_1
+    rx391_cur."!mark_push"(0, rx391_pos, $I10)
   # rx subrule "hexint" subtype=capture negate=
-    rx408_cur."!cursor_pos"(rx408_pos)
-    $P10 = rx408_cur."hexint"()
-    unless $P10, rx408_fail
-    rx408_cur."!mark_push"(0, -1, 0, $P10)
+    rx391_cur."!cursor_pos"(rx391_pos)
+    $P10 = rx391_cur."hexint"()
+    unless $P10, rx391_fail
+    rx391_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("hexint")
-    rx408_pos = $P10."pos"()
-    goto alt417_end
-  alt417_1:
+    rx391_pos = $P10."pos"()
+    goto alt400_end
+  alt400_1:
   # rx literal  "["
-    add $I11, rx408_pos, 1
-    gt $I11, rx408_eos, rx408_fail
-    sub $I11, rx408_pos, rx408_off
-    substr $S10, rx408_tgt, $I11, 1
-    ne $S10, "[", rx408_fail
-    add rx408_pos, 1
+    add $I11, rx391_pos, 1
+    gt $I11, rx391_eos, rx391_fail
+    sub $I11, rx391_pos, rx391_off
+    substr $S10, rx391_tgt, $I11, 1
+    ne $S10, "[", rx391_fail
+    add rx391_pos, 1
   # rx subrule "hexints" subtype=capture negate=
-    rx408_cur."!cursor_pos"(rx408_pos)
-    $P10 = rx408_cur."hexints"()
-    unless $P10, rx408_fail
-    rx408_cur."!mark_push"(0, -1, 0, $P10)
+    rx391_cur."!cursor_pos"(rx391_pos)
+    $P10 = rx391_cur."hexints"()
+    unless $P10, rx391_fail
+    rx391_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("hexints")
-    rx408_pos = $P10."pos"()
+    rx391_pos = $P10."pos"()
   # rx literal  "]"
-    add $I11, rx408_pos, 1
-    gt $I11, rx408_eos, rx408_fail
-    sub $I11, rx408_pos, rx408_off
-    substr $S10, rx408_tgt, $I11, 1
-    ne $S10, "]", rx408_fail
-    add rx408_pos, 1
-  alt417_end:
-  # rx pass
-    rx408_cur."!cursor_pass"(rx408_pos, "backslash:sym<x>")
-    rx408_cur."!cursor_debug"("PASS  ", "backslash:sym<x>", " at pos=", rx408_pos)
-    .return (rx408_cur)
-  rx408_fail:
-.annotate 'line', 3
-    (rx408_rep, rx408_pos, $I10, $P10) = rx408_cur."!mark_fail"(0)
-    lt rx408_pos, -1, rx408_done
-    eq rx408_pos, -1, rx408_fail
-    jump $I10
-  rx408_done:
-    rx408_cur."!cursor_fail"()
-    rx408_cur."!cursor_debug"("FAIL  ", "backslash:sym<x>")
-    .return (rx408_cur)
+    add $I11, rx391_pos, 1
+    gt $I11, rx391_eos, rx391_fail
+    sub $I11, rx391_pos, rx391_off
+    substr $S10, rx391_tgt, $I11, 1
+    ne $S10, "]", rx391_fail
+    add rx391_pos, 1
+  alt400_end:
+  # rx pass
+    rx391_cur."!cursor_pass"(rx391_pos, "backslash:sym<x>")
+    rx391_cur."!cursor_debug"("PASS  ", "backslash:sym<x>", " at pos=", rx391_pos)
+    .return (rx391_cur)
+  rx391_restart:
+.annotate 'line', 3
+    rx391_cur."!cursor_debug"("NEXT ", "backslash:sym<x>")
+  rx391_fail:
+    (rx391_rep, rx391_pos, $I10, $P10) = rx391_cur."!mark_fail"(0)
+    lt rx391_pos, -1, rx391_done
+    eq rx391_pos, -1, rx391_fail
+    jump $I10
+  rx391_done:
+    rx391_cur."!cursor_fail"()
+    rx391_cur."!cursor_debug"("FAIL  ", "backslash:sym<x>")
+    .return (rx391_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<x>"  :subid("114_1278500530.77787") :method
-.annotate 'line', 3
-    $P410 = self."!PREFIX__!subrule"("hexints", "X[")
-    $P411 = self."!PREFIX__!subrule"("hexint", "X")
-    $P412 = self."!PREFIX__!subrule"("hexints", "x[")
-    $P413 = self."!PREFIX__!subrule"("hexint", "x")
-    new $P414, "ResizablePMCArray"
-    push $P414, $P410
-    push $P414, $P411
-    push $P414, $P412
-    push $P414, $P413
-    .return ($P414)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<c>"  :subid("115_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx419_tgt
-    .local int rx419_pos
-    .local int rx419_off
-    .local int rx419_eos
-    .local int rx419_rep
-    .local pmc rx419_cur
-    (rx419_cur, rx419_pos, rx419_tgt) = self."!cursor_start"()
-    rx419_cur."!cursor_debug"("START ", "backslash:sym<c>")
-    .lex unicode:"$\x{a2}", rx419_cur
-    .local pmc match
-    .lex "$/", match
-    length rx419_eos, rx419_tgt
-    gt rx419_pos, rx419_eos, rx419_done
-    set rx419_off, 0
-    lt rx419_pos, 2, rx419_start
-    sub rx419_off, rx419_pos, 1
-    substr rx419_tgt, rx419_tgt, rx419_off
-  rx419_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan424_done
-    goto rxscan424_scan
-  rxscan424_loop:
-    ($P10) = rx419_cur."from"()
-    inc $P10
-    set rx419_pos, $P10
-    ge rx419_pos, rx419_eos, rxscan424_done
-  rxscan424_scan:
-    set_addr $I10, rxscan424_loop
-    rx419_cur."!mark_push"(0, rx419_pos, $I10)
-  rxscan424_done:
+.sub "!PREFIX__backslash:sym<x>"  :subid("114_1279529218.55263") :method
+.annotate 'line', 3
+    $P393 = self."!PREFIX__!subrule"("hexints", "X[")
+    $P394 = self."!PREFIX__!subrule"("hexint", "X")
+    $P395 = self."!PREFIX__!subrule"("hexints", "x[")
+    $P396 = self."!PREFIX__!subrule"("hexint", "x")
+    new $P397, "ResizablePMCArray"
+    push $P397, $P393
+    push $P397, $P394
+    push $P397, $P395
+    push $P397, $P396
+    .return ($P397)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "backslash:sym<c>"  :subid("115_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx402_tgt
+    .local int rx402_pos
+    .local int rx402_off
+    .local int rx402_eos
+    .local int rx402_rep
+    .local pmc rx402_cur
+    (rx402_cur, rx402_pos, rx402_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx402_cur
+    .local pmc match
+    .lex "$/", match
+    length rx402_eos, rx402_tgt
+    gt rx402_pos, rx402_eos, rx402_done
+    set rx402_off, 0
+    lt rx402_pos, 2, rx402_start
+    sub rx402_off, rx402_pos, 1
+    substr rx402_tgt, rx402_tgt, rx402_off
+  rx402_start:
+    eq $I10, 1, rx402_restart
+    rx402_cur."!cursor_debug"("START ", "backslash:sym<c>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan407_done
+    goto rxscan407_scan
+  rxscan407_loop:
+    ($P10) = rx402_cur."from"()
+    inc $P10
+    set rx402_pos, $P10
+    ge rx402_pos, rx402_eos, rxscan407_done
+  rxscan407_scan:
+    set_addr $I10, rxscan407_loop
+    rx402_cur."!mark_push"(0, rx402_pos, $I10)
+  rxscan407_done:
 .annotate 'line', 133
   # rx subcapture "sym"
-    set_addr $I10, rxcap_425_fail
-    rx419_cur."!mark_push"(0, rx419_pos, $I10)
+    set_addr $I10, rxcap_408_fail
+    rx402_cur."!mark_push"(0, rx402_pos, $I10)
   # rx enumcharlist negate=0 
-    ge rx419_pos, rx419_eos, rx419_fail
-    sub $I10, rx419_pos, rx419_off
-    substr $S10, rx419_tgt, $I10, 1
+    ge rx402_pos, rx402_eos, rx402_fail
+    sub $I10, rx402_pos, rx402_off
+    substr $S10, rx402_tgt, $I10, 1
     index $I11, "cC", $S10
-    lt $I11, 0, rx419_fail
-    inc rx419_pos
-    set_addr $I10, rxcap_425_fail
-    ($I12, $I11) = rx419_cur."!mark_peek"($I10)
-    rx419_cur."!cursor_pos"($I11)
-    ($P10) = rx419_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx419_pos, "")
-    rx419_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, 0, rx402_fail
+    inc rx402_pos
+    set_addr $I10, rxcap_408_fail
+    ($I12, $I11) = rx402_cur."!mark_peek"($I10)
+    rx402_cur."!cursor_pos"($I11)
+    ($P10) = rx402_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx402_pos, "")
+    rx402_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_425_done
-  rxcap_425_fail:
-    goto rx419_fail
-  rxcap_425_done:
+    goto rxcap_408_done
+  rxcap_408_fail:
+    goto rx402_fail
+  rxcap_408_done:
   # rx subrule "charspec" subtype=capture negate=
-    rx419_cur."!cursor_pos"(rx419_pos)
-    $P10 = rx419_cur."charspec"()
-    unless $P10, rx419_fail
-    rx419_cur."!mark_push"(0, -1, 0, $P10)
+    rx402_cur."!cursor_pos"(rx402_pos)
+    $P10 = rx402_cur."charspec"()
+    unless $P10, rx402_fail
+    rx402_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("charspec")
-    rx419_pos = $P10."pos"()
+    rx402_pos = $P10."pos"()
   # rx pass
-    rx419_cur."!cursor_pass"(rx419_pos, "backslash:sym<c>")
-    rx419_cur."!cursor_debug"("PASS  ", "backslash:sym<c>", " at pos=", rx419_pos)
-    .return (rx419_cur)
-  rx419_fail:
+    rx402_cur."!cursor_pass"(rx402_pos, "backslash:sym<c>")
+    rx402_cur."!cursor_debug"("PASS  ", "backslash:sym<c>", " at pos=", rx402_pos)
+    .return (rx402_cur)
+  rx402_restart:
 .annotate 'line', 3
-    (rx419_rep, rx419_pos, $I10, $P10) = rx419_cur."!mark_fail"(0)
-    lt rx419_pos, -1, rx419_done
-    eq rx419_pos, -1, rx419_fail
+    rx402_cur."!cursor_debug"("NEXT ", "backslash:sym<c>")
+  rx402_fail:
+    (rx402_rep, rx402_pos, $I10, $P10) = rx402_cur."!mark_fail"(0)
+    lt rx402_pos, -1, rx402_done
+    eq rx402_pos, -1, rx402_fail
     jump $I10
-  rx419_done:
-    rx419_cur."!cursor_fail"()
-    rx419_cur."!cursor_debug"("FAIL  ", "backslash:sym<c>")
-    .return (rx419_cur)
+  rx402_done:
+    rx402_cur."!cursor_fail"()
+    rx402_cur."!cursor_debug"("FAIL  ", "backslash:sym<c>")
+    .return (rx402_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<c>"  :subid("116_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<c>"  :subid("116_1279529218.55263") :method
 .annotate 'line', 3
-    $P421 = self."!PREFIX__!subrule"("charspec", "C")
-    $P422 = self."!PREFIX__!subrule"("charspec", "c")
-    new $P423, "ResizablePMCArray"
-    push $P423, $P421
-    push $P423, $P422
-    .return ($P423)
+    $P404 = self."!PREFIX__!subrule"("charspec", "C")
+    $P405 = self."!PREFIX__!subrule"("charspec", "c")
+    new $P406, "ResizablePMCArray"
+    push $P406, $P404
+    push $P406, $P405
+    .return ($P406)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<A>"  :subid("117_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<A>"  :subid("117_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx427_tgt
-    .local int rx427_pos
-    .local int rx427_off
-    .local int rx427_eos
-    .local int rx427_rep
-    .local pmc rx427_cur
-    (rx427_cur, rx427_pos, rx427_tgt) = self."!cursor_start"()
-    rx427_cur."!cursor_debug"("START ", "backslash:sym<A>")
-    .lex unicode:"$\x{a2}", rx427_cur
+    .local string rx410_tgt
+    .local int rx410_pos
+    .local int rx410_off
+    .local int rx410_eos
+    .local int rx410_rep
+    .local pmc rx410_cur
+    (rx410_cur, rx410_pos, rx410_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx410_cur
     .local pmc match
     .lex "$/", match
-    length rx427_eos, rx427_tgt
-    gt rx427_pos, rx427_eos, rx427_done
-    set rx427_off, 0
-    lt rx427_pos, 2, rx427_start
-    sub rx427_off, rx427_pos, 1
-    substr rx427_tgt, rx427_tgt, rx427_off
-  rx427_start:
+    length rx410_eos, rx410_tgt
+    gt rx410_pos, rx410_eos, rx410_done
+    set rx410_off, 0
+    lt rx410_pos, 2, rx410_start
+    sub rx410_off, rx410_pos, 1
+    substr rx410_tgt, rx410_tgt, rx410_off
+  rx410_start:
+    eq $I10, 1, rx410_restart
+    rx410_cur."!cursor_debug"("START ", "backslash:sym<A>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan431_done
-    goto rxscan431_scan
-  rxscan431_loop:
-    ($P10) = rx427_cur."from"()
+    ne $I10, -1, rxscan414_done
+    goto rxscan414_scan
+  rxscan414_loop:
+    ($P10) = rx410_cur."from"()
     inc $P10
-    set rx427_pos, $P10
-    ge rx427_pos, rx427_eos, rxscan431_done
-  rxscan431_scan:
-    set_addr $I10, rxscan431_loop
-    rx427_cur."!mark_push"(0, rx427_pos, $I10)
-  rxscan431_done:
+    set rx410_pos, $P10
+    ge rx410_pos, rx410_eos, rxscan414_done
+  rxscan414_scan:
+    set_addr $I10, rxscan414_loop
+    rx410_cur."!mark_push"(0, rx410_pos, $I10)
+  rxscan414_done:
 .annotate 'line', 134
   # rx literal  "A"
-    add $I11, rx427_pos, 1
-    gt $I11, rx427_eos, rx427_fail
-    sub $I11, rx427_pos, rx427_off
-    substr $S10, rx427_tgt, $I11, 1
-    ne $S10, "A", rx427_fail
-    add rx427_pos, 1
+    add $I11, rx410_pos, 1
+    gt $I11, rx410_eos, rx410_fail
+    sub $I11, rx410_pos, rx410_off
+    substr $S10, rx410_tgt, $I11, 1
+    ne $S10, "A", rx410_fail
+    add rx410_pos, 1
   # rx subrule "obs" subtype=method negate=
-    rx427_cur."!cursor_pos"(rx427_pos)
-    $P10 = rx427_cur."obs"("\\A as beginning-of-string matcher", "^")
-    unless $P10, rx427_fail
-    rx427_pos = $P10."pos"()
+    rx410_cur."!cursor_pos"(rx410_pos)
+    $P10 = rx410_cur."obs"("\\A as beginning-of-string matcher", "^")
+    unless $P10, rx410_fail
+    rx410_pos = $P10."pos"()
   # rx pass
-    rx427_cur."!cursor_pass"(rx427_pos, "backslash:sym<A>")
-    rx427_cur."!cursor_debug"("PASS  ", "backslash:sym<A>", " at pos=", rx427_pos)
-    .return (rx427_cur)
-  rx427_fail:
+    rx410_cur."!cursor_pass"(rx410_pos, "backslash:sym<A>")
+    rx410_cur."!cursor_debug"("PASS  ", "backslash:sym<A>", " at pos=", rx410_pos)
+    .return (rx410_cur)
+  rx410_restart:
 .annotate 'line', 3
-    (rx427_rep, rx427_pos, $I10, $P10) = rx427_cur."!mark_fail"(0)
-    lt rx427_pos, -1, rx427_done
-    eq rx427_pos, -1, rx427_fail
+    rx410_cur."!cursor_debug"("NEXT ", "backslash:sym<A>")
+  rx410_fail:
+    (rx410_rep, rx410_pos, $I10, $P10) = rx410_cur."!mark_fail"(0)
+    lt rx410_pos, -1, rx410_done
+    eq rx410_pos, -1, rx410_fail
     jump $I10
-  rx427_done:
-    rx427_cur."!cursor_fail"()
-    rx427_cur."!cursor_debug"("FAIL  ", "backslash:sym<A>")
-    .return (rx427_cur)
+  rx410_done:
+    rx410_cur."!cursor_fail"()
+    rx410_cur."!cursor_debug"("FAIL  ", "backslash:sym<A>")
+    .return (rx410_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<A>"  :subid("118_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<A>"  :subid("118_1279529218.55263") :method
 .annotate 'line', 3
-    $P429 = self."!PREFIX__!subrule"("obs", "A")
-    new $P430, "ResizablePMCArray"
-    push $P430, $P429
-    .return ($P430)
+    $P412 = self."!PREFIX__!subrule"("obs", "A")
+    new $P413, "ResizablePMCArray"
+    push $P413, $P412
+    .return ($P413)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<z>"  :subid("119_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<z>"  :subid("119_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx433_tgt
-    .local int rx433_pos
-    .local int rx433_off
-    .local int rx433_eos
-    .local int rx433_rep
-    .local pmc rx433_cur
-    (rx433_cur, rx433_pos, rx433_tgt) = self."!cursor_start"()
-    rx433_cur."!cursor_debug"("START ", "backslash:sym<z>")
-    .lex unicode:"$\x{a2}", rx433_cur
+    .local string rx416_tgt
+    .local int rx416_pos
+    .local int rx416_off
+    .local int rx416_eos
+    .local int rx416_rep
+    .local pmc rx416_cur
+    (rx416_cur, rx416_pos, rx416_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx416_cur
     .local pmc match
     .lex "$/", match
-    length rx433_eos, rx433_tgt
-    gt rx433_pos, rx433_eos, rx433_done
-    set rx433_off, 0
-    lt rx433_pos, 2, rx433_start
-    sub rx433_off, rx433_pos, 1
-    substr rx433_tgt, rx433_tgt, rx433_off
-  rx433_start:
+    length rx416_eos, rx416_tgt
+    gt rx416_pos, rx416_eos, rx416_done
+    set rx416_off, 0
+    lt rx416_pos, 2, rx416_start
+    sub rx416_off, rx416_pos, 1
+    substr rx416_tgt, rx416_tgt, rx416_off
+  rx416_start:
+    eq $I10, 1, rx416_restart
+    rx416_cur."!cursor_debug"("START ", "backslash:sym<z>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan437_done
-    goto rxscan437_scan
-  rxscan437_loop:
-    ($P10) = rx433_cur."from"()
+    ne $I10, -1, rxscan420_done
+    goto rxscan420_scan
+  rxscan420_loop:
+    ($P10) = rx416_cur."from"()
     inc $P10
-    set rx433_pos, $P10
-    ge rx433_pos, rx433_eos, rxscan437_done
-  rxscan437_scan:
-    set_addr $I10, rxscan437_loop
-    rx433_cur."!mark_push"(0, rx433_pos, $I10)
-  rxscan437_done:
+    set rx416_pos, $P10
+    ge rx416_pos, rx416_eos, rxscan420_done
+  rxscan420_scan:
+    set_addr $I10, rxscan420_loop
+    rx416_cur."!mark_push"(0, rx416_pos, $I10)
+  rxscan420_done:
 .annotate 'line', 135
   # rx literal  "z"
-    add $I11, rx433_pos, 1
-    gt $I11, rx433_eos, rx433_fail
-    sub $I11, rx433_pos, rx433_off
-    substr $S10, rx433_tgt, $I11, 1
-    ne $S10, "z", rx433_fail
-    add rx433_pos, 1
+    add $I11, rx416_pos, 1
+    gt $I11, rx416_eos, rx416_fail
+    sub $I11, rx416_pos, rx416_off
+    substr $S10, rx416_tgt, $I11, 1
+    ne $S10, "z", rx416_fail
+    add rx416_pos, 1
   # rx subrule "obs" subtype=method negate=
-    rx433_cur."!cursor_pos"(rx433_pos)
-    $P10 = rx433_cur."obs"("\\z as end-of-string matcher", "$")
-    unless $P10, rx433_fail
-    rx433_pos = $P10."pos"()
+    rx416_cur."!cursor_pos"(rx416_pos)
+    $P10 = rx416_cur."obs"("\\z as end-of-string matcher", "$")
+    unless $P10, rx416_fail
+    rx416_pos = $P10."pos"()
   # rx pass
-    rx433_cur."!cursor_pass"(rx433_pos, "backslash:sym<z>")
-    rx433_cur."!cursor_debug"("PASS  ", "backslash:sym<z>", " at pos=", rx433_pos)
-    .return (rx433_cur)
-  rx433_fail:
+    rx416_cur."!cursor_pass"(rx416_pos, "backslash:sym<z>")
+    rx416_cur."!cursor_debug"("PASS  ", "backslash:sym<z>", " at pos=", rx416_pos)
+    .return (rx416_cur)
+  rx416_restart:
 .annotate 'line', 3
-    (rx433_rep, rx433_pos, $I10, $P10) = rx433_cur."!mark_fail"(0)
-    lt rx433_pos, -1, rx433_done
-    eq rx433_pos, -1, rx433_fail
+    rx416_cur."!cursor_debug"("NEXT ", "backslash:sym<z>")
+  rx416_fail:
+    (rx416_rep, rx416_pos, $I10, $P10) = rx416_cur."!mark_fail"(0)
+    lt rx416_pos, -1, rx416_done
+    eq rx416_pos, -1, rx416_fail
     jump $I10
-  rx433_done:
-    rx433_cur."!cursor_fail"()
-    rx433_cur."!cursor_debug"("FAIL  ", "backslash:sym<z>")
-    .return (rx433_cur)
+  rx416_done:
+    rx416_cur."!cursor_fail"()
+    rx416_cur."!cursor_debug"("FAIL  ", "backslash:sym<z>")
+    .return (rx416_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<z>"  :subid("120_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<z>"  :subid("120_1279529218.55263") :method
 .annotate 'line', 3
-    $P435 = self."!PREFIX__!subrule"("obs", "z")
-    new $P436, "ResizablePMCArray"
-    push $P436, $P435
-    .return ($P436)
+    $P418 = self."!PREFIX__!subrule"("obs", "z")
+    new $P419, "ResizablePMCArray"
+    push $P419, $P418
+    .return ($P419)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<Z>"  :subid("121_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<Z>"  :subid("121_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx439_tgt
-    .local int rx439_pos
-    .local int rx439_off
-    .local int rx439_eos
-    .local int rx439_rep
-    .local pmc rx439_cur
-    (rx439_cur, rx439_pos, rx439_tgt) = self."!cursor_start"()
-    rx439_cur."!cursor_debug"("START ", "backslash:sym<Z>")
-    .lex unicode:"$\x{a2}", rx439_cur
-    .local pmc match
-    .lex "$/", match
-    length rx439_eos, rx439_tgt
-    gt rx439_pos, rx439_eos, rx439_done
-    set rx439_off, 0
-    lt rx439_pos, 2, rx439_start
-    sub rx439_off, rx439_pos, 1
-    substr rx439_tgt, rx439_tgt, rx439_off
-  rx439_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan443_done
-    goto rxscan443_scan
-  rxscan443_loop:
-    ($P10) = rx439_cur."from"()
-    inc $P10
-    set rx439_pos, $P10
-    ge rx439_pos, rx439_eos, rxscan443_done
-  rxscan443_scan:
-    set_addr $I10, rxscan443_loop
-    rx439_cur."!mark_push"(0, rx439_pos, $I10)
-  rxscan443_done:
+    .local string rx422_tgt
+    .local int rx422_pos
+    .local int rx422_off
+    .local int rx422_eos
+    .local int rx422_rep
+    .local pmc rx422_cur
+    (rx422_cur, rx422_pos, rx422_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx422_cur
+    .local pmc match
+    .lex "$/", match
+    length rx422_eos, rx422_tgt
+    gt rx422_pos, rx422_eos, rx422_done
+    set rx422_off, 0
+    lt rx422_pos, 2, rx422_start
+    sub rx422_off, rx422_pos, 1
+    substr rx422_tgt, rx422_tgt, rx422_off
+  rx422_start:
+    eq $I10, 1, rx422_restart
+    rx422_cur."!cursor_debug"("START ", "backslash:sym<Z>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan426_done
+    goto rxscan426_scan
+  rxscan426_loop:
+    ($P10) = rx422_cur."from"()
+    inc $P10
+    set rx422_pos, $P10
+    ge rx422_pos, rx422_eos, rxscan426_done
+  rxscan426_scan:
+    set_addr $I10, rxscan426_loop
+    rx422_cur."!mark_push"(0, rx422_pos, $I10)
+  rxscan426_done:
 .annotate 'line', 136
   # rx literal  "Z"
-    add $I11, rx439_pos, 1
-    gt $I11, rx439_eos, rx439_fail
-    sub $I11, rx439_pos, rx439_off
-    substr $S10, rx439_tgt, $I11, 1
-    ne $S10, "Z", rx439_fail
-    add rx439_pos, 1
+    add $I11, rx422_pos, 1
+    gt $I11, rx422_eos, rx422_fail
+    sub $I11, rx422_pos, rx422_off
+    substr $S10, rx422_tgt, $I11, 1
+    ne $S10, "Z", rx422_fail
+    add rx422_pos, 1
   # rx subrule "obs" subtype=method negate=
-    rx439_cur."!cursor_pos"(rx439_pos)
-    $P10 = rx439_cur."obs"("\\Z as end-of-string matcher", "\\n?$")
-    unless $P10, rx439_fail
-    rx439_pos = $P10."pos"()
+    rx422_cur."!cursor_pos"(rx422_pos)
+    $P10 = rx422_cur."obs"("\\Z as end-of-string matcher", "\\n?$")
+    unless $P10, rx422_fail
+    rx422_pos = $P10."pos"()
   # rx pass
-    rx439_cur."!cursor_pass"(rx439_pos, "backslash:sym<Z>")
-    rx439_cur."!cursor_debug"("PASS  ", "backslash:sym<Z>", " at pos=", rx439_pos)
-    .return (rx439_cur)
-  rx439_fail:
+    rx422_cur."!cursor_pass"(rx422_pos, "backslash:sym<Z>")
+    rx422_cur."!cursor_debug"("PASS  ", "backslash:sym<Z>", " at pos=", rx422_pos)
+    .return (rx422_cur)
+  rx422_restart:
 .annotate 'line', 3
-    (rx439_rep, rx439_pos, $I10, $P10) = rx439_cur."!mark_fail"(0)
-    lt rx439_pos, -1, rx439_done
-    eq rx439_pos, -1, rx439_fail
+    rx422_cur."!cursor_debug"("NEXT ", "backslash:sym<Z>")
+  rx422_fail:
+    (rx422_rep, rx422_pos, $I10, $P10) = rx422_cur."!mark_fail"(0)
+    lt rx422_pos, -1, rx422_done
+    eq rx422_pos, -1, rx422_fail
     jump $I10
-  rx439_done:
-    rx439_cur."!cursor_fail"()
-    rx439_cur."!cursor_debug"("FAIL  ", "backslash:sym<Z>")
-    .return (rx439_cur)
+  rx422_done:
+    rx422_cur."!cursor_fail"()
+    rx422_cur."!cursor_debug"("FAIL  ", "backslash:sym<Z>")
+    .return (rx422_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<Z>"  :subid("122_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<Z>"  :subid("122_1279529218.55263") :method
 .annotate 'line', 3
-    $P441 = self."!PREFIX__!subrule"("obs", "Z")
-    new $P442, "ResizablePMCArray"
-    push $P442, $P441
-    .return ($P442)
+    $P424 = self."!PREFIX__!subrule"("obs", "Z")
+    new $P425, "ResizablePMCArray"
+    push $P425, $P424
+    .return ($P425)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<Q>"  :subid("123_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "backslash:sym<Q>"  :subid("123_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx445_tgt
-    .local int rx445_pos
-    .local int rx445_off
-    .local int rx445_eos
-    .local int rx445_rep
-    .local pmc rx445_cur
-    (rx445_cur, rx445_pos, rx445_tgt) = self."!cursor_start"()
-    rx445_cur."!cursor_debug"("START ", "backslash:sym<Q>")
-    .lex unicode:"$\x{a2}", rx445_cur
+    .local string rx428_tgt
+    .local int rx428_pos
+    .local int rx428_off
+    .local int rx428_eos
+    .local int rx428_rep
+    .local pmc rx428_cur
+    (rx428_cur, rx428_pos, rx428_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx428_cur
     .local pmc match
     .lex "$/", match
-    length rx445_eos, rx445_tgt
-    gt rx445_pos, rx445_eos, rx445_done
-    set rx445_off, 0
-    lt rx445_pos, 2, rx445_start
-    sub rx445_off, rx445_pos, 1
-    substr rx445_tgt, rx445_tgt, rx445_off
-  rx445_start:
+    length rx428_eos, rx428_tgt
+    gt rx428_pos, rx428_eos, rx428_done
+    set rx428_off, 0
+    lt rx428_pos, 2, rx428_start
+    sub rx428_off, rx428_pos, 1
+    substr rx428_tgt, rx428_tgt, rx428_off
+  rx428_start:
+    eq $I10, 1, rx428_restart
+    rx428_cur."!cursor_debug"("START ", "backslash:sym<Q>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan449_done
-    goto rxscan449_scan
-  rxscan449_loop:
-    ($P10) = rx445_cur."from"()
+    ne $I10, -1, rxscan432_done
+    goto rxscan432_scan
+  rxscan432_loop:
+    ($P10) = rx428_cur."from"()
     inc $P10
-    set rx445_pos, $P10
-    ge rx445_pos, rx445_eos, rxscan449_done
-  rxscan449_scan:
-    set_addr $I10, rxscan449_loop
-    rx445_cur."!mark_push"(0, rx445_pos, $I10)
-  rxscan449_done:
+    set rx428_pos, $P10
+    ge rx428_pos, rx428_eos, rxscan432_done
+  rxscan432_scan:
+    set_addr $I10, rxscan432_loop
+    rx428_cur."!mark_push"(0, rx428_pos, $I10)
+  rxscan432_done:
 .annotate 'line', 137
   # rx literal  "Q"
-    add $I11, rx445_pos, 1
-    gt $I11, rx445_eos, rx445_fail
-    sub $I11, rx445_pos, rx445_off
-    substr $S10, rx445_tgt, $I11, 1
-    ne $S10, "Q", rx445_fail
-    add rx445_pos, 1
+    add $I11, rx428_pos, 1
+    gt $I11, rx428_eos, rx428_fail
+    sub $I11, rx428_pos, rx428_off
+    substr $S10, rx428_tgt, $I11, 1
+    ne $S10, "Q", rx428_fail
+    add rx428_pos, 1
   # rx subrule "obs" subtype=method negate=
-    rx445_cur."!cursor_pos"(rx445_pos)
-    $P10 = rx445_cur."obs"("\\Q as quotemeta", "quotes or literal variable match")
-    unless $P10, rx445_fail
-    rx445_pos = $P10."pos"()
+    rx428_cur."!cursor_pos"(rx428_pos)
+    $P10 = rx428_cur."obs"("\\Q as quotemeta", "quotes or literal variable match")
+    unless $P10, rx428_fail
+    rx428_pos = $P10."pos"()
+  # rx pass
+    rx428_cur."!cursor_pass"(rx428_pos, "backslash:sym<Q>")
+    rx428_cur."!cursor_debug"("PASS  ", "backslash:sym<Q>", " at pos=", rx428_pos)
+    .return (rx428_cur)
+  rx428_restart:
+.annotate 'line', 3
+    rx428_cur."!cursor_debug"("NEXT ", "backslash:sym<Q>")
+  rx428_fail:
+    (rx428_rep, rx428_pos, $I10, $P10) = rx428_cur."!mark_fail"(0)
+    lt rx428_pos, -1, rx428_done
+    eq rx428_pos, -1, rx428_fail
+    jump $I10
+  rx428_done:
+    rx428_cur."!cursor_fail"()
+    rx428_cur."!cursor_debug"("FAIL  ", "backslash:sym<Q>")
+    .return (rx428_cur)
+    .return ()
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "!PREFIX__backslash:sym<Q>"  :subid("124_1279529218.55263") :method
+.annotate 'line', 3
+    $P430 = self."!PREFIX__!subrule"("obs", "Q")
+    new $P431, "ResizablePMCArray"
+    push $P431, $P430
+    .return ($P431)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "backslash:sym<misc>"  :subid("125_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx434_tgt
+    .local int rx434_pos
+    .local int rx434_off
+    .local int rx434_eos
+    .local int rx434_rep
+    .local pmc rx434_cur
+    (rx434_cur, rx434_pos, rx434_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx434_cur
+    .local pmc match
+    .lex "$/", match
+    length rx434_eos, rx434_tgt
+    gt rx434_pos, rx434_eos, rx434_done
+    set rx434_off, 0
+    lt rx434_pos, 2, rx434_start
+    sub rx434_off, rx434_pos, 1
+    substr rx434_tgt, rx434_tgt, rx434_off
+  rx434_start:
+    eq $I10, 1, rx434_restart
+    rx434_cur."!cursor_debug"("START ", "backslash:sym<misc>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan437_done
+    goto rxscan437_scan
+  rxscan437_loop:
+    ($P10) = rx434_cur."from"()
+    inc $P10
+    set rx434_pos, $P10
+    ge rx434_pos, rx434_eos, rxscan437_done
+  rxscan437_scan:
+    set_addr $I10, rxscan437_loop
+    rx434_cur."!mark_push"(0, rx434_pos, $I10)
+  rxscan437_done:
+.annotate 'line', 138
+  # rx charclass W
+    ge rx434_pos, rx434_eos, rx434_fail
+    sub $I10, rx434_pos, rx434_off
+    is_cclass $I11, 8192, rx434_tgt, $I10
+    if $I11, rx434_fail
+    inc rx434_pos
   # rx pass
-    rx445_cur."!cursor_pass"(rx445_pos, "backslash:sym<Q>")
-    rx445_cur."!cursor_debug"("PASS  ", "backslash:sym<Q>", " at pos=", rx445_pos)
-    .return (rx445_cur)
-  rx445_fail:
+    rx434_cur."!cursor_pass"(rx434_pos, "backslash:sym<misc>")
+    rx434_cur."!cursor_debug"("PASS  ", "backslash:sym<misc>", " at pos=", rx434_pos)
+    .return (rx434_cur)
+  rx434_restart:
 .annotate 'line', 3
-    (rx445_rep, rx445_pos, $I10, $P10) = rx445_cur."!mark_fail"(0)
-    lt rx445_pos, -1, rx445_done
-    eq rx445_pos, -1, rx445_fail
+    rx434_cur."!cursor_debug"("NEXT ", "backslash:sym<misc>")
+  rx434_fail:
+    (rx434_rep, rx434_pos, $I10, $P10) = rx434_cur."!mark_fail"(0)
+    lt rx434_pos, -1, rx434_done
+    eq rx434_pos, -1, rx434_fail
     jump $I10
-  rx445_done:
-    rx445_cur."!cursor_fail"()
-    rx445_cur."!cursor_debug"("FAIL  ", "backslash:sym<Q>")
-    .return (rx445_cur)
+  rx434_done:
+    rx434_cur."!cursor_fail"()
+    rx434_cur."!cursor_debug"("FAIL  ", "backslash:sym<misc>")
+    .return (rx434_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<Q>"  :subid("124_1278500530.77787") :method
+.sub "!PREFIX__backslash:sym<misc>"  :subid("126_1279529218.55263") :method
+.annotate 'line', 3
+    new $P436, "ResizablePMCArray"
+    push $P436, ""
+    .return ($P436)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "assertion"  :subid("127_1279529218.55263") :method
+.annotate 'line', 140
+    $P439 = self."!protoregex"("assertion")
+    .return ($P439)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "!PREFIX__assertion"  :subid("128_1279529218.55263") :method
+.annotate 'line', 140
+    $P441 = self."!PREFIX__!protoregex"("assertion")
+    .return ($P441)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "assertion:sym<?>"  :subid("129_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .const 'Sub' $P450 = "131_1279529218.55263" 
+    capture_lex $P450
+    .local string rx443_tgt
+    .local int rx443_pos
+    .local int rx443_off
+    .local int rx443_eos
+    .local int rx443_rep
+    .local pmc rx443_cur
+    (rx443_cur, rx443_pos, rx443_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx443_cur
+    .local pmc match
+    .lex "$/", match
+    length rx443_eos, rx443_tgt
+    gt rx443_pos, rx443_eos, rx443_done
+    set rx443_off, 0
+    lt rx443_pos, 2, rx443_start
+    sub rx443_off, rx443_pos, 1
+    substr rx443_tgt, rx443_tgt, rx443_off
+  rx443_start:
+    eq $I10, 1, rx443_restart
+    rx443_cur."!cursor_debug"("START ", "assertion:sym<?>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan447_done
+    goto rxscan447_scan
+  rxscan447_loop:
+    ($P10) = rx443_cur."from"()
+    inc $P10
+    set rx443_pos, $P10
+    ge rx443_pos, rx443_eos, rxscan447_done
+  rxscan447_scan:
+    set_addr $I10, rxscan447_loop
+    rx443_cur."!mark_push"(0, rx443_pos, $I10)
+  rxscan447_done:
+.annotate 'line', 142
+  # rx literal  "?"
+    add $I11, rx443_pos, 1
+    gt $I11, rx443_eos, rx443_fail
+    sub $I11, rx443_pos, rx443_off
+    substr $S10, rx443_tgt, $I11, 1
+    ne $S10, "?", rx443_fail
+    add rx443_pos, 1
+  alt448_0:
+    set_addr $I10, alt448_1
+    rx443_cur."!mark_push"(0, rx443_pos, $I10)
+  # rx subrule "before" subtype=zerowidth negate=
+    rx443_cur."!cursor_pos"(rx443_pos)
+    .const 'Sub' $P450 = "131_1279529218.55263" 
+    capture_lex $P450
+    $P10 = rx443_cur."before"($P450)
+    unless $P10, rx443_fail
+    goto alt448_end
+  alt448_1:
+  # rx subrule "assertion" subtype=capture negate=
+    rx443_cur."!cursor_pos"(rx443_pos)
+    $P10 = rx443_cur."assertion"()
+    unless $P10, rx443_fail
+    rx443_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("assertion")
+    rx443_pos = $P10."pos"()
+  alt448_end:
+  # rx pass
+    rx443_cur."!cursor_pass"(rx443_pos, "assertion:sym<?>")
+    rx443_cur."!cursor_debug"("PASS  ", "assertion:sym<?>", " at pos=", rx443_pos)
+    .return (rx443_cur)
+  rx443_restart:
 .annotate 'line', 3
-    $P447 = self."!PREFIX__!subrule"("obs", "Q")
-    new $P448, "ResizablePMCArray"
-    push $P448, $P447
-    .return ($P448)
+    rx443_cur."!cursor_debug"("NEXT ", "assertion:sym<?>")
+  rx443_fail:
+    (rx443_rep, rx443_pos, $I10, $P10) = rx443_cur."!mark_fail"(0)
+    lt rx443_pos, -1, rx443_done
+    eq rx443_pos, -1, rx443_fail
+    jump $I10
+  rx443_done:
+    rx443_cur."!cursor_fail"()
+    rx443_cur."!cursor_debug"("FAIL  ", "assertion:sym<?>")
+    .return (rx443_cur)
+    .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "backslash:sym<misc>"  :subid("125_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "!PREFIX__assertion:sym<?>"  :subid("130_1279529218.55263") :method
 .annotate 'line', 3
+    $P445 = self."!PREFIX__!subrule"("assertion", "?")
+    new $P446, "ResizablePMCArray"
+    push $P446, $P445
+    push $P446, "?"
+    .return ($P446)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "_block449"  :anon :subid("131_1279529218.55263") :method :outer("129_1279529218.55263")
+.annotate 'line', 142
     .local string rx451_tgt
     .local int rx451_pos
     .local int rx451_off
     .local int rx451_eos
     .local int rx451_rep
     .local pmc rx451_cur
-    (rx451_cur, rx451_pos, rx451_tgt) = self."!cursor_start"()
-    rx451_cur."!cursor_debug"("START ", "backslash:sym<misc>")
+    (rx451_cur, rx451_pos, rx451_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx451_cur
     .local pmc match
     .lex "$/", match
@@ -5465,229 +5856,293 @@
     sub rx451_off, rx451_pos, 1
     substr rx451_tgt, rx451_tgt, rx451_off
   rx451_start:
+    eq $I10, 1, rx451_restart
+    rx451_cur."!cursor_debug"("START ", "")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan454_done
-    goto rxscan454_scan
-  rxscan454_loop:
+    ne $I10, -1, rxscan452_done
+    goto rxscan452_scan
+  rxscan452_loop:
     ($P10) = rx451_cur."from"()
     inc $P10
     set rx451_pos, $P10
-    ge rx451_pos, rx451_eos, rxscan454_done
-  rxscan454_scan:
-    set_addr $I10, rxscan454_loop
+    ge rx451_pos, rx451_eos, rxscan452_done
+  rxscan452_scan:
+    set_addr $I10, rxscan452_loop
     rx451_cur."!mark_push"(0, rx451_pos, $I10)
-  rxscan454_done:
-.annotate 'line', 138
-  # rx charclass W
-    ge rx451_pos, rx451_eos, rx451_fail
-    sub $I10, rx451_pos, rx451_off
-    is_cclass $I11, 8192, rx451_tgt, $I10
-    if $I11, rx451_fail
-    inc rx451_pos
+  rxscan452_done:
+  # rx literal  ">"
+    add $I11, rx451_pos, 1
+    gt $I11, rx451_eos, rx451_fail
+    sub $I11, rx451_pos, rx451_off
+    substr $S10, rx451_tgt, $I11, 1
+    ne $S10, ">", rx451_fail
+    add rx451_pos, 1
   # rx pass
-    rx451_cur."!cursor_pass"(rx451_pos, "backslash:sym<misc>")
-    rx451_cur."!cursor_debug"("PASS  ", "backslash:sym<misc>", " at pos=", rx451_pos)
+    rx451_cur."!cursor_pass"(rx451_pos, "")
+    rx451_cur."!cursor_debug"("PASS  ", "", " at pos=", rx451_pos)
     .return (rx451_cur)
+  rx451_restart:
+    rx451_cur."!cursor_debug"("NEXT ", "")
   rx451_fail:
-.annotate 'line', 3
     (rx451_rep, rx451_pos, $I10, $P10) = rx451_cur."!mark_fail"(0)
     lt rx451_pos, -1, rx451_done
     eq rx451_pos, -1, rx451_fail
     jump $I10
   rx451_done:
     rx451_cur."!cursor_fail"()
-    rx451_cur."!cursor_debug"("FAIL  ", "backslash:sym<misc>")
+    rx451_cur."!cursor_debug"("FAIL  ", "")
     .return (rx451_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__backslash:sym<misc>"  :subid("126_1278500530.77787") :method
-.annotate 'line', 3
-    new $P453, "ResizablePMCArray"
-    push $P453, ""
-    .return ($P453)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "assertion"  :subid("127_1278500530.77787") :method
-.annotate 'line', 140
-    $P456 = self."!protoregex"("assertion")
-    .return ($P456)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__assertion"  :subid("128_1278500530.77787") :method
-.annotate 'line', 140
-    $P458 = self."!PREFIX__!protoregex"("assertion")
-    .return ($P458)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "assertion:sym<?>"  :subid("129_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "assertion:sym<!>"  :subid("132_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .const 'Sub' $P467 = "131_1278500530.77787" 
-    capture_lex $P467
-    .local string rx460_tgt
-    .local int rx460_pos
-    .local int rx460_off
-    .local int rx460_eos
-    .local int rx460_rep
-    .local pmc rx460_cur
-    (rx460_cur, rx460_pos, rx460_tgt) = self."!cursor_start"()
-    rx460_cur."!cursor_debug"("START ", "assertion:sym<?>")
-    .lex unicode:"$\x{a2}", rx460_cur
-    .local pmc match
-    .lex "$/", match
-    length rx460_eos, rx460_tgt
-    gt rx460_pos, rx460_eos, rx460_done
-    set rx460_off, 0
-    lt rx460_pos, 2, rx460_start
-    sub rx460_off, rx460_pos, 1
-    substr rx460_tgt, rx460_tgt, rx460_off
-  rx460_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan464_done
-    goto rxscan464_scan
-  rxscan464_loop:
-    ($P10) = rx460_cur."from"()
-    inc $P10
-    set rx460_pos, $P10
-    ge rx460_pos, rx460_eos, rxscan464_done
-  rxscan464_scan:
-    set_addr $I10, rxscan464_loop
-    rx460_cur."!mark_push"(0, rx460_pos, $I10)
-  rxscan464_done:
-.annotate 'line', 142
-  # rx literal  "?"
-    add $I11, rx460_pos, 1
-    gt $I11, rx460_eos, rx460_fail
-    sub $I11, rx460_pos, rx460_off
-    substr $S10, rx460_tgt, $I11, 1
-    ne $S10, "?", rx460_fail
-    add rx460_pos, 1
-  alt465_0:
-    set_addr $I10, alt465_1
-    rx460_cur."!mark_push"(0, rx460_pos, $I10)
+    .const 'Sub' $P461 = "134_1279529218.55263" 
+    capture_lex $P461
+    .local string rx454_tgt
+    .local int rx454_pos
+    .local int rx454_off
+    .local int rx454_eos
+    .local int rx454_rep
+    .local pmc rx454_cur
+    (rx454_cur, rx454_pos, rx454_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx454_cur
+    .local pmc match
+    .lex "$/", match
+    length rx454_eos, rx454_tgt
+    gt rx454_pos, rx454_eos, rx454_done
+    set rx454_off, 0
+    lt rx454_pos, 2, rx454_start
+    sub rx454_off, rx454_pos, 1
+    substr rx454_tgt, rx454_tgt, rx454_off
+  rx454_start:
+    eq $I10, 1, rx454_restart
+    rx454_cur."!cursor_debug"("START ", "assertion:sym<!>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan458_done
+    goto rxscan458_scan
+  rxscan458_loop:
+    ($P10) = rx454_cur."from"()
+    inc $P10
+    set rx454_pos, $P10
+    ge rx454_pos, rx454_eos, rxscan458_done
+  rxscan458_scan:
+    set_addr $I10, rxscan458_loop
+    rx454_cur."!mark_push"(0, rx454_pos, $I10)
+  rxscan458_done:
+.annotate 'line', 143
+  # rx literal  "!"
+    add $I11, rx454_pos, 1
+    gt $I11, rx454_eos, rx454_fail
+    sub $I11, rx454_pos, rx454_off
+    substr $S10, rx454_tgt, $I11, 1
+    ne $S10, "!", rx454_fail
+    add rx454_pos, 1
+  alt459_0:
+    set_addr $I10, alt459_1
+    rx454_cur."!mark_push"(0, rx454_pos, $I10)
   # rx subrule "before" subtype=zerowidth negate=
-    rx460_cur."!cursor_pos"(rx460_pos)
-    .const 'Sub' $P467 = "131_1278500530.77787" 
-    capture_lex $P467
-    $P10 = rx460_cur."before"($P467)
-    unless $P10, rx460_fail
-    goto alt465_end
-  alt465_1:
+    rx454_cur."!cursor_pos"(rx454_pos)
+    .const 'Sub' $P461 = "134_1279529218.55263" 
+    capture_lex $P461
+    $P10 = rx454_cur."before"($P461)
+    unless $P10, rx454_fail
+    goto alt459_end
+  alt459_1:
   # rx subrule "assertion" subtype=capture negate=
-    rx460_cur."!cursor_pos"(rx460_pos)
-    $P10 = rx460_cur."assertion"()
-    unless $P10, rx460_fail
-    rx460_cur."!mark_push"(0, -1, 0, $P10)
+    rx454_cur."!cursor_pos"(rx454_pos)
+    $P10 = rx454_cur."assertion"()
+    unless $P10, rx454_fail
+    rx454_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("assertion")
-    rx460_pos = $P10."pos"()
-  alt465_end:
+    rx454_pos = $P10."pos"()
+  alt459_end:
   # rx pass
-    rx460_cur."!cursor_pass"(rx460_pos, "assertion:sym<?>")
-    rx460_cur."!cursor_debug"("PASS  ", "assertion:sym<?>", " at pos=", rx460_pos)
-    .return (rx460_cur)
-  rx460_fail:
+    rx454_cur."!cursor_pass"(rx454_pos, "assertion:sym<!>")
+    rx454_cur."!cursor_debug"("PASS  ", "assertion:sym<!>", " at pos=", rx454_pos)
+    .return (rx454_cur)
+  rx454_restart:
 .annotate 'line', 3
-    (rx460_rep, rx460_pos, $I10, $P10) = rx460_cur."!mark_fail"(0)
-    lt rx460_pos, -1, rx460_done
-    eq rx460_pos, -1, rx460_fail
+    rx454_cur."!cursor_debug"("NEXT ", "assertion:sym<!>")
+  rx454_fail:
+    (rx454_rep, rx454_pos, $I10, $P10) = rx454_cur."!mark_fail"(0)
+    lt rx454_pos, -1, rx454_done
+    eq rx454_pos, -1, rx454_fail
     jump $I10
-  rx460_done:
-    rx460_cur."!cursor_fail"()
-    rx460_cur."!cursor_debug"("FAIL  ", "assertion:sym<?>")
-    .return (rx460_cur)
+  rx454_done:
+    rx454_cur."!cursor_fail"()
+    rx454_cur."!cursor_debug"("FAIL  ", "assertion:sym<!>")
+    .return (rx454_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__assertion:sym<?>"  :subid("130_1278500530.77787") :method
+.sub "!PREFIX__assertion:sym<!>"  :subid("133_1279529218.55263") :method
 .annotate 'line', 3
-    $P462 = self."!PREFIX__!subrule"("assertion", "?")
-    new $P463, "ResizablePMCArray"
-    push $P463, $P462
-    push $P463, "?"
-    .return ($P463)
+    $P456 = self."!PREFIX__!subrule"("assertion", "!")
+    new $P457, "ResizablePMCArray"
+    push $P457, $P456
+    push $P457, "!"
+    .return ($P457)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block466"  :anon :subid("131_1278500530.77787") :method :outer("129_1278500530.77787")
-.annotate 'line', 142
-    .local string rx468_tgt
-    .local int rx468_pos
-    .local int rx468_off
-    .local int rx468_eos
-    .local int rx468_rep
-    .local pmc rx468_cur
-    (rx468_cur, rx468_pos, rx468_tgt) = self."!cursor_start"()
-    rx468_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx468_cur
-    .local pmc match
-    .lex "$/", match
-    length rx468_eos, rx468_tgt
-    gt rx468_pos, rx468_eos, rx468_done
-    set rx468_off, 0
-    lt rx468_pos, 2, rx468_start
-    sub rx468_off, rx468_pos, 1
-    substr rx468_tgt, rx468_tgt, rx468_off
-  rx468_start:
+.sub "_block460"  :anon :subid("134_1279529218.55263") :method :outer("132_1279529218.55263")
+.annotate 'line', 143
+    .local string rx462_tgt
+    .local int rx462_pos
+    .local int rx462_off
+    .local int rx462_eos
+    .local int rx462_rep
+    .local pmc rx462_cur
+    (rx462_cur, rx462_pos, rx462_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx462_cur
+    .local pmc match
+    .lex "$/", match
+    length rx462_eos, rx462_tgt
+    gt rx462_pos, rx462_eos, rx462_done
+    set rx462_off, 0
+    lt rx462_pos, 2, rx462_start
+    sub rx462_off, rx462_pos, 1
+    substr rx462_tgt, rx462_tgt, rx462_off
+  rx462_start:
+    eq $I10, 1, rx462_restart
+    rx462_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan463_done
+    goto rxscan463_scan
+  rxscan463_loop:
+    ($P10) = rx462_cur."from"()
+    inc $P10
+    set rx462_pos, $P10
+    ge rx462_pos, rx462_eos, rxscan463_done
+  rxscan463_scan:
+    set_addr $I10, rxscan463_loop
+    rx462_cur."!mark_push"(0, rx462_pos, $I10)
+  rxscan463_done:
+  # rx literal  ">"
+    add $I11, rx462_pos, 1
+    gt $I11, rx462_eos, rx462_fail
+    sub $I11, rx462_pos, rx462_off
+    substr $S10, rx462_tgt, $I11, 1
+    ne $S10, ">", rx462_fail
+    add rx462_pos, 1
+  # rx pass
+    rx462_cur."!cursor_pass"(rx462_pos, "")
+    rx462_cur."!cursor_debug"("PASS  ", "", " at pos=", rx462_pos)
+    .return (rx462_cur)
+  rx462_restart:
+    rx462_cur."!cursor_debug"("NEXT ", "")
+  rx462_fail:
+    (rx462_rep, rx462_pos, $I10, $P10) = rx462_cur."!mark_fail"(0)
+    lt rx462_pos, -1, rx462_done
+    eq rx462_pos, -1, rx462_fail
+    jump $I10
+  rx462_done:
+    rx462_cur."!cursor_fail"()
+    rx462_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx462_cur)
+    .return ()
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "assertion:sym<method>"  :subid("135_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .local string rx465_tgt
+    .local int rx465_pos
+    .local int rx465_off
+    .local int rx465_eos
+    .local int rx465_rep
+    .local pmc rx465_cur
+    (rx465_cur, rx465_pos, rx465_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx465_cur
+    .local pmc match
+    .lex "$/", match
+    length rx465_eos, rx465_tgt
+    gt rx465_pos, rx465_eos, rx465_done
+    set rx465_off, 0
+    lt rx465_pos, 2, rx465_start
+    sub rx465_off, rx465_pos, 1
+    substr rx465_tgt, rx465_tgt, rx465_off
+  rx465_start:
+    eq $I10, 1, rx465_restart
+    rx465_cur."!cursor_debug"("START ", "assertion:sym<method>")
     $I10 = self.'from'()
     ne $I10, -1, rxscan469_done
     goto rxscan469_scan
   rxscan469_loop:
-    ($P10) = rx468_cur."from"()
+    ($P10) = rx465_cur."from"()
     inc $P10
-    set rx468_pos, $P10
-    ge rx468_pos, rx468_eos, rxscan469_done
+    set rx465_pos, $P10
+    ge rx465_pos, rx465_eos, rxscan469_done
   rxscan469_scan:
     set_addr $I10, rxscan469_loop
-    rx468_cur."!mark_push"(0, rx468_pos, $I10)
+    rx465_cur."!mark_push"(0, rx465_pos, $I10)
   rxscan469_done:
-  # rx literal  ">"
-    add $I11, rx468_pos, 1
-    gt $I11, rx468_eos, rx468_fail
-    sub $I11, rx468_pos, rx468_off
-    substr $S10, rx468_tgt, $I11, 1
-    ne $S10, ">", rx468_fail
-    add rx468_pos, 1
+.annotate 'line', 146
+  # rx literal  "."
+    add $I11, rx465_pos, 1
+    gt $I11, rx465_eos, rx465_fail
+    sub $I11, rx465_pos, rx465_off
+    substr $S10, rx465_tgt, $I11, 1
+    ne $S10, ".", rx465_fail
+    add rx465_pos, 1
+  # rx subrule "assertion" subtype=capture negate=
+    rx465_cur."!cursor_pos"(rx465_pos)
+    $P10 = rx465_cur."assertion"()
+    unless $P10, rx465_fail
+    rx465_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("assertion")
+    rx465_pos = $P10."pos"()
+.annotate 'line', 145
   # rx pass
-    rx468_cur."!cursor_pass"(rx468_pos, "")
-    rx468_cur."!cursor_debug"("PASS  ", "", " at pos=", rx468_pos)
-    .return (rx468_cur)
-  rx468_fail:
-    (rx468_rep, rx468_pos, $I10, $P10) = rx468_cur."!mark_fail"(0)
-    lt rx468_pos, -1, rx468_done
-    eq rx468_pos, -1, rx468_fail
+    rx465_cur."!cursor_pass"(rx465_pos, "assertion:sym<method>")
+    rx465_cur."!cursor_debug"("PASS  ", "assertion:sym<method>", " at pos=", rx465_pos)
+    .return (rx465_cur)
+  rx465_restart:
+.annotate 'line', 3
+    rx465_cur."!cursor_debug"("NEXT ", "assertion:sym<method>")
+  rx465_fail:
+    (rx465_rep, rx465_pos, $I10, $P10) = rx465_cur."!mark_fail"(0)
+    lt rx465_pos, -1, rx465_done
+    eq rx465_pos, -1, rx465_fail
     jump $I10
-  rx468_done:
-    rx468_cur."!cursor_fail"()
-    rx468_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx468_cur)
+  rx465_done:
+    rx465_cur."!cursor_fail"()
+    rx465_cur."!cursor_debug"("FAIL  ", "assertion:sym<method>")
+    .return (rx465_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "assertion:sym<!>"  :subid("132_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "!PREFIX__assertion:sym<method>"  :subid("136_1279529218.55263") :method
 .annotate 'line', 3
-    .const 'Sub' $P478 = "134_1278500530.77787" 
-    capture_lex $P478
+    $P467 = self."!PREFIX__!subrule"("assertion", ".")
+    new $P468, "ResizablePMCArray"
+    push $P468, $P467
+    .return ($P468)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Grammar"]
+.sub "assertion:sym<name>"  :subid("137_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .const 'Sub' $P479 = "139_1279529218.55263" 
+    capture_lex $P479
     .local string rx471_tgt
     .local int rx471_pos
     .local int rx471_off
     .local int rx471_eos
     .local int rx471_rep
     .local pmc rx471_cur
-    (rx471_cur, rx471_pos, rx471_tgt) = self."!cursor_start"()
-    rx471_cur."!cursor_debug"("START ", "assertion:sym<!>")
+    (rx471_cur, rx471_pos, rx471_tgt, $I10) = self."!cursor_start"()
+    rx471_cur."!cursor_caparray"("assertion", "nibbler", "arglist")
     .lex unicode:"$\x{a2}", rx471_cur
     .local pmc match
     .lex "$/", match
@@ -5698,6 +6153,8 @@
     sub rx471_off, rx471_pos, 1
     substr rx471_tgt, rx471_tgt, rx471_off
   rx471_start:
+    eq $I10, 1, rx471_restart
+    rx471_cur."!cursor_debug"("START ", "assertion:sym<name>")
     $I10 = self.'from'()
     ne $I10, -1, rxscan475_done
     goto rxscan475_scan
@@ -5710,25 +6167,42 @@
     set_addr $I10, rxscan475_loop
     rx471_cur."!mark_push"(0, rx471_pos, $I10)
   rxscan475_done:
-.annotate 'line', 143
-  # rx literal  "!"
+.annotate 'line', 150
+  # rx subrule "identifier" subtype=capture negate=
+    rx471_cur."!cursor_pos"(rx471_pos)
+    $P10 = rx471_cur."identifier"()
+    unless $P10, rx471_fail
+    rx471_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("longname")
+    rx471_pos = $P10."pos"()
+.annotate 'line', 157
+  # rx rxquantr476 ** 0..1
+    set_addr $I10, rxquantr476_done
+    rx471_cur."!mark_push"(0, rx471_pos, $I10)
+  rxquantr476_loop:
+  alt477_0:
+.annotate 'line', 151
+    set_addr $I10, alt477_1
+    rx471_cur."!mark_push"(0, rx471_pos, $I10)
+.annotate 'line', 152
+  # rx subrule "before" subtype=zerowidth negate=
+    rx471_cur."!cursor_pos"(rx471_pos)
+    .const 'Sub' $P479 = "139_1279529218.55263" 
+    capture_lex $P479
+    $P10 = rx471_cur."before"($P479)
+    unless $P10, rx471_fail
+    goto alt477_end
+  alt477_1:
+    set_addr $I10, alt477_2
+    rx471_cur."!mark_push"(0, rx471_pos, $I10)
+.annotate 'line', 153
+  # rx literal  "="
     add $I11, rx471_pos, 1
     gt $I11, rx471_eos, rx471_fail
     sub $I11, rx471_pos, rx471_off
     substr $S10, rx471_tgt, $I11, 1
-    ne $S10, "!", rx471_fail
+    ne $S10, "=", rx471_fail
     add rx471_pos, 1
-  alt476_0:
-    set_addr $I10, alt476_1
-    rx471_cur."!mark_push"(0, rx471_pos, $I10)
-  # rx subrule "before" subtype=zerowidth negate=
-    rx471_cur."!cursor_pos"(rx471_pos)
-    .const 'Sub' $P478 = "134_1278500530.77787" 
-    capture_lex $P478
-    $P10 = rx471_cur."before"($P478)
-    unless $P10, rx471_fail
-    goto alt476_end
-  alt476_1:
   # rx subrule "assertion" subtype=capture negate=
     rx471_cur."!cursor_pos"(rx471_pos)
     $P10 = rx471_cur."assertion"()
@@ -5736,495 +6210,584 @@
     rx471_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("assertion")
     rx471_pos = $P10."pos"()
-  alt476_end:
-  # rx pass
-    rx471_cur."!cursor_pass"(rx471_pos, "assertion:sym<!>")
-    rx471_cur."!cursor_debug"("PASS  ", "assertion:sym<!>", " at pos=", rx471_pos)
-    .return (rx471_cur)
-  rx471_fail:
+    goto alt477_end
+  alt477_2:
+    set_addr $I10, alt477_3
+    rx471_cur."!mark_push"(0, rx471_pos, $I10)
+.annotate 'line', 154
+  # rx literal  ":"
+    add $I11, rx471_pos, 1
+    gt $I11, rx471_eos, rx471_fail
+    sub $I11, rx471_pos, rx471_off
+    substr $S10, rx471_tgt, $I11, 1
+    ne $S10, ":", rx471_fail
+    add rx471_pos, 1
+  # rx subrule "arglist" subtype=capture negate=
+    rx471_cur."!cursor_pos"(rx471_pos)
+    $P10 = rx471_cur."arglist"()
+    unless $P10, rx471_fail
+    rx471_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("arglist")
+    rx471_pos = $P10."pos"()
+    goto alt477_end
+  alt477_3:
+    set_addr $I10, alt477_4
+    rx471_cur."!mark_push"(0, rx471_pos, $I10)
+.annotate 'line', 155
+  # rx literal  "("
+    add $I11, rx471_pos, 1
+    gt $I11, rx471_eos, rx471_fail
+    sub $I11, rx471_pos, rx471_off
+    substr $S10, rx471_tgt, $I11, 1
+    ne $S10, "(", rx471_fail
+    add rx471_pos, 1
+  # rx subrule "arglist" subtype=capture negate=
+    rx471_cur."!cursor_pos"(rx471_pos)
+    $P10 = rx471_cur."arglist"()
+    unless $P10, rx471_fail
+    rx471_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("arglist")
+    rx471_pos = $P10."pos"()
+  # rx literal  ")"
+    add $I11, rx471_pos, 1
+    gt $I11, rx471_eos, rx471_fail
+    sub $I11, rx471_pos, rx471_off
+    substr $S10, rx471_tgt, $I11, 1
+    ne $S10, ")", rx471_fail
+    add rx471_pos, 1
+    goto alt477_end
+  alt477_4:
+.annotate 'line', 156
+  # rx subrule "normspace" subtype=method negate=
+    rx471_cur."!cursor_pos"(rx471_pos)
+    $P10 = rx471_cur."normspace"()
+    unless $P10, rx471_fail
+    rx471_pos = $P10."pos"()
+  # rx subrule "nibbler" subtype=capture negate=
+    rx471_cur."!cursor_pos"(rx471_pos)
+    $P10 = rx471_cur."nibbler"()
+    unless $P10, rx471_fail
+    rx471_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("nibbler")
+    rx471_pos = $P10."pos"()
+  alt477_end:
+.annotate 'line', 157
+    set_addr $I10, rxquantr476_done
+    (rx471_rep) = rx471_cur."!mark_commit"($I10)
+  rxquantr476_done:
+.annotate 'line', 149
+  # rx pass
+    rx471_cur."!cursor_pass"(rx471_pos, "assertion:sym<name>")
+    rx471_cur."!cursor_debug"("PASS  ", "assertion:sym<name>", " at pos=", rx471_pos)
+    .return (rx471_cur)
+  rx471_restart:
 .annotate 'line', 3
+    rx471_cur."!cursor_debug"("NEXT ", "assertion:sym<name>")
+  rx471_fail:
     (rx471_rep, rx471_pos, $I10, $P10) = rx471_cur."!mark_fail"(0)
     lt rx471_pos, -1, rx471_done
     eq rx471_pos, -1, rx471_fail
     jump $I10
   rx471_done:
     rx471_cur."!cursor_fail"()
-    rx471_cur."!cursor_debug"("FAIL  ", "assertion:sym<!>")
+    rx471_cur."!cursor_debug"("FAIL  ", "assertion:sym<name>")
     .return (rx471_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__assertion:sym<!>"  :subid("133_1278500530.77787") :method
+.sub "!PREFIX__assertion:sym<name>"  :subid("138_1279529218.55263") :method
 .annotate 'line', 3
-    $P473 = self."!PREFIX__!subrule"("assertion", "!")
+    $P473 = self."!PREFIX__!subrule"("identifier", "")
     new $P474, "ResizablePMCArray"
     push $P474, $P473
-    push $P474, "!"
     .return ($P474)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block477"  :anon :subid("134_1278500530.77787") :method :outer("132_1278500530.77787")
-.annotate 'line', 143
-    .local string rx479_tgt
-    .local int rx479_pos
-    .local int rx479_off
-    .local int rx479_eos
-    .local int rx479_rep
-    .local pmc rx479_cur
-    (rx479_cur, rx479_pos, rx479_tgt) = self."!cursor_start"()
-    rx479_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx479_cur
-    .local pmc match
-    .lex "$/", match
-    length rx479_eos, rx479_tgt
-    gt rx479_pos, rx479_eos, rx479_done
-    set rx479_off, 0
-    lt rx479_pos, 2, rx479_start
-    sub rx479_off, rx479_pos, 1
-    substr rx479_tgt, rx479_tgt, rx479_off
-  rx479_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan480_done
-    goto rxscan480_scan
-  rxscan480_loop:
-    ($P10) = rx479_cur."from"()
-    inc $P10
-    set rx479_pos, $P10
-    ge rx479_pos, rx479_eos, rxscan480_done
-  rxscan480_scan:
-    set_addr $I10, rxscan480_loop
-    rx479_cur."!mark_push"(0, rx479_pos, $I10)
-  rxscan480_done:
+.sub "_block478"  :anon :subid("139_1279529218.55263") :method :outer("137_1279529218.55263")
+.annotate 'line', 152
+    .local string rx480_tgt
+    .local int rx480_pos
+    .local int rx480_off
+    .local int rx480_eos
+    .local int rx480_rep
+    .local pmc rx480_cur
+    (rx480_cur, rx480_pos, rx480_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx480_cur
+    .local pmc match
+    .lex "$/", match
+    length rx480_eos, rx480_tgt
+    gt rx480_pos, rx480_eos, rx480_done
+    set rx480_off, 0
+    lt rx480_pos, 2, rx480_start
+    sub rx480_off, rx480_pos, 1
+    substr rx480_tgt, rx480_tgt, rx480_off
+  rx480_start:
+    eq $I10, 1, rx480_restart
+    rx480_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan481_done
+    goto rxscan481_scan
+  rxscan481_loop:
+    ($P10) = rx480_cur."from"()
+    inc $P10
+    set rx480_pos, $P10
+    ge rx480_pos, rx480_eos, rxscan481_done
+  rxscan481_scan:
+    set_addr $I10, rxscan481_loop
+    rx480_cur."!mark_push"(0, rx480_pos, $I10)
+  rxscan481_done:
   # rx literal  ">"
-    add $I11, rx479_pos, 1
-    gt $I11, rx479_eos, rx479_fail
-    sub $I11, rx479_pos, rx479_off
-    substr $S10, rx479_tgt, $I11, 1
-    ne $S10, ">", rx479_fail
-    add rx479_pos, 1
-  # rx pass
-    rx479_cur."!cursor_pass"(rx479_pos, "")
-    rx479_cur."!cursor_debug"("PASS  ", "", " at pos=", rx479_pos)
-    .return (rx479_cur)
-  rx479_fail:
-    (rx479_rep, rx479_pos, $I10, $P10) = rx479_cur."!mark_fail"(0)
-    lt rx479_pos, -1, rx479_done
-    eq rx479_pos, -1, rx479_fail
-    jump $I10
-  rx479_done:
-    rx479_cur."!cursor_fail"()
-    rx479_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx479_cur)
+    add $I11, rx480_pos, 1
+    gt $I11, rx480_eos, rx480_fail
+    sub $I11, rx480_pos, rx480_off
+    substr $S10, rx480_tgt, $I11, 1
+    ne $S10, ">", rx480_fail
+    add rx480_pos, 1
+  # rx pass
+    rx480_cur."!cursor_pass"(rx480_pos, "")
+    rx480_cur."!cursor_debug"("PASS  ", "", " at pos=", rx480_pos)
+    .return (rx480_cur)
+  rx480_restart:
+    rx480_cur."!cursor_debug"("NEXT ", "")
+  rx480_fail:
+    (rx480_rep, rx480_pos, $I10, $P10) = rx480_cur."!mark_fail"(0)
+    lt rx480_pos, -1, rx480_done
+    eq rx480_pos, -1, rx480_fail
+    jump $I10
+  rx480_done:
+    rx480_cur."!cursor_fail"()
+    rx480_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx480_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "assertion:sym<method>"  :subid("135_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .local string rx482_tgt
-    .local int rx482_pos
-    .local int rx482_off
-    .local int rx482_eos
-    .local int rx482_rep
-    .local pmc rx482_cur
-    (rx482_cur, rx482_pos, rx482_tgt) = self."!cursor_start"()
-    rx482_cur."!cursor_debug"("START ", "assertion:sym<method>")
-    .lex unicode:"$\x{a2}", rx482_cur
-    .local pmc match
-    .lex "$/", match
-    length rx482_eos, rx482_tgt
-    gt rx482_pos, rx482_eos, rx482_done
-    set rx482_off, 0
-    lt rx482_pos, 2, rx482_start
-    sub rx482_off, rx482_pos, 1
-    substr rx482_tgt, rx482_tgt, rx482_off
-  rx482_start:
+.sub "assertion:sym<[>"  :subid("140_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .const 'Sub' $P488 = "142_1279529218.55263" 
+    capture_lex $P488
+    .local string rx483_tgt
+    .local int rx483_pos
+    .local int rx483_off
+    .local int rx483_eos
+    .local int rx483_rep
+    .local pmc rx483_cur
+    (rx483_cur, rx483_pos, rx483_tgt, $I10) = self."!cursor_start"()
+    rx483_cur."!cursor_caparray"("cclass_elem")
+    .lex unicode:"$\x{a2}", rx483_cur
+    .local pmc match
+    .lex "$/", match
+    length rx483_eos, rx483_tgt
+    gt rx483_pos, rx483_eos, rx483_done
+    set rx483_off, 0
+    lt rx483_pos, 2, rx483_start
+    sub rx483_off, rx483_pos, 1
+    substr rx483_tgt, rx483_tgt, rx483_off
+  rx483_start:
+    eq $I10, 1, rx483_restart
+    rx483_cur."!cursor_debug"("START ", "assertion:sym<[>")
     $I10 = self.'from'()
     ne $I10, -1, rxscan486_done
     goto rxscan486_scan
   rxscan486_loop:
-    ($P10) = rx482_cur."from"()
+    ($P10) = rx483_cur."from"()
     inc $P10
-    set rx482_pos, $P10
-    ge rx482_pos, rx482_eos, rxscan486_done
+    set rx483_pos, $P10
+    ge rx483_pos, rx483_eos, rxscan486_done
   rxscan486_scan:
     set_addr $I10, rxscan486_loop
-    rx482_cur."!mark_push"(0, rx482_pos, $I10)
+    rx483_cur."!mark_push"(0, rx483_pos, $I10)
   rxscan486_done:
-.annotate 'line', 146
-  # rx literal  "."
-    add $I11, rx482_pos, 1
-    gt $I11, rx482_eos, rx482_fail
-    sub $I11, rx482_pos, rx482_off
-    substr $S10, rx482_tgt, $I11, 1
-    ne $S10, ".", rx482_fail
-    add rx482_pos, 1
-  # rx subrule "assertion" subtype=capture negate=
-    rx482_cur."!cursor_pos"(rx482_pos)
-    $P10 = rx482_cur."assertion"()
-    unless $P10, rx482_fail
-    rx482_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("assertion")
-    rx482_pos = $P10."pos"()
-.annotate 'line', 145
+.annotate 'line', 160
+  # rx subrule "before" subtype=zerowidth negate=
+    rx483_cur."!cursor_pos"(rx483_pos)
+    .const 'Sub' $P488 = "142_1279529218.55263" 
+    capture_lex $P488
+    $P10 = rx483_cur."before"($P488)
+    unless $P10, rx483_fail
+  # rx rxquantr492 ** 1..*
+    set_addr $I10, rxquantr492_done
+    rx483_cur."!mark_push"(0, -1, $I10)
+  rxquantr492_loop:
+  # rx subrule "cclass_elem" subtype=capture negate=
+    rx483_cur."!cursor_pos"(rx483_pos)
+    $P10 = rx483_cur."cclass_elem"()
+    unless $P10, rx483_fail
+    goto rxsubrule493_pass
+  rxsubrule493_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx483_fail
+  rxsubrule493_pass:
+    set_addr $I10, rxsubrule493_back
+    rx483_cur."!mark_push"(0, rx483_pos, $I10, $P10)
+    $P10."!cursor_names"("cclass_elem")
+    rx483_pos = $P10."pos"()
+    set_addr $I10, rxquantr492_done
+    (rx483_rep) = rx483_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr492_done
+    rx483_cur."!mark_push"(rx483_rep, rx483_pos, $I10)
+    goto rxquantr492_loop
+  rxquantr492_done:
   # rx pass
-    rx482_cur."!cursor_pass"(rx482_pos, "assertion:sym<method>")
-    rx482_cur."!cursor_debug"("PASS  ", "assertion:sym<method>", " at pos=", rx482_pos)
-    .return (rx482_cur)
-  rx482_fail:
+    rx483_cur."!cursor_pass"(rx483_pos, "assertion:sym<[>")
+    rx483_cur."!cursor_debug"("PASS  ", "assertion:sym<[>", " at pos=", rx483_pos)
+    .return (rx483_cur)
+  rx483_restart:
 .annotate 'line', 3
-    (rx482_rep, rx482_pos, $I10, $P10) = rx482_cur."!mark_fail"(0)
-    lt rx482_pos, -1, rx482_done
-    eq rx482_pos, -1, rx482_fail
+    rx483_cur."!cursor_debug"("NEXT ", "assertion:sym<[>")
+  rx483_fail:
+    (rx483_rep, rx483_pos, $I10, $P10) = rx483_cur."!mark_fail"(0)
+    lt rx483_pos, -1, rx483_done
+    eq rx483_pos, -1, rx483_fail
     jump $I10
-  rx482_done:
-    rx482_cur."!cursor_fail"()
-    rx482_cur."!cursor_debug"("FAIL  ", "assertion:sym<method>")
-    .return (rx482_cur)
+  rx483_done:
+    rx483_cur."!cursor_fail"()
+    rx483_cur."!cursor_debug"("FAIL  ", "assertion:sym<[>")
+    .return (rx483_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__assertion:sym<method>"  :subid("136_1278500530.77787") :method
+.sub "!PREFIX__assertion:sym<[>"  :subid("141_1279529218.55263") :method
 .annotate 'line', 3
-    $P484 = self."!PREFIX__!subrule"("assertion", ".")
     new $P485, "ResizablePMCArray"
-    push $P485, $P484
+    push $P485, ""
     .return ($P485)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "assertion:sym<name>"  :subid("137_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .const 'Sub' $P496 = "139_1278500530.77787" 
-    capture_lex $P496
-    .local string rx488_tgt
-    .local int rx488_pos
-    .local int rx488_off
-    .local int rx488_eos
-    .local int rx488_rep
-    .local pmc rx488_cur
-    (rx488_cur, rx488_pos, rx488_tgt) = self."!cursor_start"()
-    rx488_cur."!cursor_debug"("START ", "assertion:sym<name>")
-    rx488_cur."!cursor_caparray"("assertion", "nibbler", "arglist")
-    .lex unicode:"$\x{a2}", rx488_cur
-    .local pmc match
-    .lex "$/", match
-    length rx488_eos, rx488_tgt
-    gt rx488_pos, rx488_eos, rx488_done
-    set rx488_off, 0
-    lt rx488_pos, 2, rx488_start
-    sub rx488_off, rx488_pos, 1
-    substr rx488_tgt, rx488_tgt, rx488_off
-  rx488_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan492_done
-    goto rxscan492_scan
-  rxscan492_loop:
-    ($P10) = rx488_cur."from"()
-    inc $P10
-    set rx488_pos, $P10
-    ge rx488_pos, rx488_eos, rxscan492_done
-  rxscan492_scan:
-    set_addr $I10, rxscan492_loop
-    rx488_cur."!mark_push"(0, rx488_pos, $I10)
-  rxscan492_done:
-.annotate 'line', 150
-  # rx subrule "identifier" subtype=capture negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    $P10 = rx488_cur."identifier"()
-    unless $P10, rx488_fail
-    rx488_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("longname")
-    rx488_pos = $P10."pos"()
-.annotate 'line', 157
-  # rx rxquantr493 ** 0..1
-    set_addr $I499, rxquantr493_done
-    rx488_cur."!mark_push"(0, rx488_pos, $I499)
-  rxquantr493_loop:
-  alt494_0:
-.annotate 'line', 151
-    set_addr $I10, alt494_1
-    rx488_cur."!mark_push"(0, rx488_pos, $I10)
-.annotate 'line', 152
-  # rx subrule "before" subtype=zerowidth negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    .const 'Sub' $P496 = "139_1278500530.77787" 
-    capture_lex $P496
-    $P10 = rx488_cur."before"($P496)
-    unless $P10, rx488_fail
-    goto alt494_end
-  alt494_1:
-    set_addr $I10, alt494_2
-    rx488_cur."!mark_push"(0, rx488_pos, $I10)
-.annotate 'line', 153
-  # rx literal  "="
-    add $I11, rx488_pos, 1
-    gt $I11, rx488_eos, rx488_fail
-    sub $I11, rx488_pos, rx488_off
-    substr $S10, rx488_tgt, $I11, 1
-    ne $S10, "=", rx488_fail
-    add rx488_pos, 1
-  # rx subrule "assertion" subtype=capture negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    $P10 = rx488_cur."assertion"()
-    unless $P10, rx488_fail
-    rx488_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("assertion")
-    rx488_pos = $P10."pos"()
-    goto alt494_end
-  alt494_2:
-    set_addr $I10, alt494_3
-    rx488_cur."!mark_push"(0, rx488_pos, $I10)
-.annotate 'line', 154
-  # rx literal  ":"
-    add $I11, rx488_pos, 1
-    gt $I11, rx488_eos, rx488_fail
-    sub $I11, rx488_pos, rx488_off
-    substr $S10, rx488_tgt, $I11, 1
-    ne $S10, ":", rx488_fail
-    add rx488_pos, 1
-  # rx subrule "arglist" subtype=capture negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    $P10 = rx488_cur."arglist"()
-    unless $P10, rx488_fail
-    rx488_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("arglist")
-    rx488_pos = $P10."pos"()
-    goto alt494_end
-  alt494_3:
-    set_addr $I10, alt494_4
-    rx488_cur."!mark_push"(0, rx488_pos, $I10)
-.annotate 'line', 155
-  # rx literal  "("
-    add $I11, rx488_pos, 1
-    gt $I11, rx488_eos, rx488_fail
-    sub $I11, rx488_pos, rx488_off
-    substr $S10, rx488_tgt, $I11, 1
-    ne $S10, "(", rx488_fail
-    add rx488_pos, 1
-  # rx subrule "arglist" subtype=capture negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    $P10 = rx488_cur."arglist"()
-    unless $P10, rx488_fail
-    rx488_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("arglist")
-    rx488_pos = $P10."pos"()
-  # rx literal  ")"
-    add $I11, rx488_pos, 1
-    gt $I11, rx488_eos, rx488_fail
-    sub $I11, rx488_pos, rx488_off
-    substr $S10, rx488_tgt, $I11, 1
-    ne $S10, ")", rx488_fail
-    add rx488_pos, 1
-    goto alt494_end
-  alt494_4:
-.annotate 'line', 156
-  # rx subrule "normspace" subtype=method negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    $P10 = rx488_cur."normspace"()
-    unless $P10, rx488_fail
-    rx488_pos = $P10."pos"()
-  # rx subrule "nibbler" subtype=capture negate=
-    rx488_cur."!cursor_pos"(rx488_pos)
-    $P10 = rx488_cur."nibbler"()
-    unless $P10, rx488_fail
-    rx488_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("nibbler")
-    rx488_pos = $P10."pos"()
-  alt494_end:
-.annotate 'line', 157
-    (rx488_rep) = rx488_cur."!mark_commit"($I499)
-  rxquantr493_done:
-.annotate 'line', 149
+.sub "_block487"  :anon :subid("142_1279529218.55263") :method :outer("140_1279529218.55263")
+.annotate 'line', 160
+    .local string rx489_tgt
+    .local int rx489_pos
+    .local int rx489_off
+    .local int rx489_eos
+    .local int rx489_rep
+    .local pmc rx489_cur
+    (rx489_cur, rx489_pos, rx489_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx489_cur
+    .local pmc match
+    .lex "$/", match
+    length rx489_eos, rx489_tgt
+    gt rx489_pos, rx489_eos, rx489_done
+    set rx489_off, 0
+    lt rx489_pos, 2, rx489_start
+    sub rx489_off, rx489_pos, 1
+    substr rx489_tgt, rx489_tgt, rx489_off
+  rx489_start:
+    eq $I10, 1, rx489_restart
+    rx489_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan490_done
+    goto rxscan490_scan
+  rxscan490_loop:
+    ($P10) = rx489_cur."from"()
+    inc $P10
+    set rx489_pos, $P10
+    ge rx489_pos, rx489_eos, rxscan490_done
+  rxscan490_scan:
+    set_addr $I10, rxscan490_loop
+    rx489_cur."!mark_push"(0, rx489_pos, $I10)
+  rxscan490_done:
+  alt491_0:
+    set_addr $I10, alt491_1
+    rx489_cur."!mark_push"(0, rx489_pos, $I10)
+  # rx literal  "["
+    add $I11, rx489_pos, 1
+    gt $I11, rx489_eos, rx489_fail
+    sub $I11, rx489_pos, rx489_off
+    substr $S10, rx489_tgt, $I11, 1
+    ne $S10, "[", rx489_fail
+    add rx489_pos, 1
+    goto alt491_end
+  alt491_1:
+    set_addr $I10, alt491_2
+    rx489_cur."!mark_push"(0, rx489_pos, $I10)
+  # rx literal  "+"
+    add $I11, rx489_pos, 1
+    gt $I11, rx489_eos, rx489_fail
+    sub $I11, rx489_pos, rx489_off
+    substr $S10, rx489_tgt, $I11, 1
+    ne $S10, "+", rx489_fail
+    add rx489_pos, 1
+    goto alt491_end
+  alt491_2:
+  # rx literal  "-"
+    add $I11, rx489_pos, 1
+    gt $I11, rx489_eos, rx489_fail
+    sub $I11, rx489_pos, rx489_off
+    substr $S10, rx489_tgt, $I11, 1
+    ne $S10, "-", rx489_fail
+    add rx489_pos, 1
+  alt491_end:
   # rx pass
-    rx488_cur."!cursor_pass"(rx488_pos, "assertion:sym<name>")
-    rx488_cur."!cursor_debug"("PASS  ", "assertion:sym<name>", " at pos=", rx488_pos)
-    .return (rx488_cur)
-  rx488_fail:
-.annotate 'line', 3
-    (rx488_rep, rx488_pos, $I10, $P10) = rx488_cur."!mark_fail"(0)
-    lt rx488_pos, -1, rx488_done
-    eq rx488_pos, -1, rx488_fail
+    rx489_cur."!cursor_pass"(rx489_pos, "")
+    rx489_cur."!cursor_debug"("PASS  ", "", " at pos=", rx489_pos)
+    .return (rx489_cur)
+  rx489_restart:
+    rx489_cur."!cursor_debug"("NEXT ", "")
+  rx489_fail:
+    (rx489_rep, rx489_pos, $I10, $P10) = rx489_cur."!mark_fail"(0)
+    lt rx489_pos, -1, rx489_done
+    eq rx489_pos, -1, rx489_fail
     jump $I10
-  rx488_done:
-    rx488_cur."!cursor_fail"()
-    rx488_cur."!cursor_debug"("FAIL  ", "assertion:sym<name>")
-    .return (rx488_cur)
+  rx489_done:
+    rx489_cur."!cursor_fail"()
+    rx489_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx489_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__assertion:sym<name>"  :subid("138_1278500530.77787") :method
+.sub "cclass_elem"  :subid("143_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    $P490 = self."!PREFIX__!subrule"("identifier", "")
-    new $P491, "ResizablePMCArray"
-    push $P491, $P490
-    .return ($P491)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block495"  :anon :subid("139_1278500530.77787") :method :outer("137_1278500530.77787")
-.annotate 'line', 152
-    .local string rx497_tgt
-    .local int rx497_pos
-    .local int rx497_off
-    .local int rx497_eos
-    .local int rx497_rep
-    .local pmc rx497_cur
-    (rx497_cur, rx497_pos, rx497_tgt) = self."!cursor_start"()
-    rx497_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx497_cur
-    .local pmc match
-    .lex "$/", match
-    length rx497_eos, rx497_tgt
-    gt rx497_pos, rx497_eos, rx497_done
-    set rx497_off, 0
-    lt rx497_pos, 2, rx497_start
-    sub rx497_off, rx497_pos, 1
-    substr rx497_tgt, rx497_tgt, rx497_off
-  rx497_start:
+    .const 'Sub' $P506 = "145_1279529218.55263" 
+    capture_lex $P506
+    .local string rx495_tgt
+    .local int rx495_pos
+    .local int rx495_off
+    .local int rx495_eos
+    .local int rx495_rep
+    .local pmc rx495_cur
+    (rx495_cur, rx495_pos, rx495_tgt, $I10) = self."!cursor_start"()
+    rx495_cur."!cursor_caparray"("charspec")
+    .lex unicode:"$\x{a2}", rx495_cur
+    .local pmc match
+    .lex "$/", match
+    length rx495_eos, rx495_tgt
+    gt rx495_pos, rx495_eos, rx495_done
+    set rx495_off, 0
+    lt rx495_pos, 2, rx495_start
+    sub rx495_off, rx495_pos, 1
+    substr rx495_tgt, rx495_tgt, rx495_off
+  rx495_start:
+    eq $I10, 1, rx495_restart
+    rx495_cur."!cursor_debug"("START ", "cclass_elem")
     $I10 = self.'from'()
     ne $I10, -1, rxscan498_done
     goto rxscan498_scan
   rxscan498_loop:
-    ($P10) = rx497_cur."from"()
+    ($P10) = rx495_cur."from"()
     inc $P10
-    set rx497_pos, $P10
-    ge rx497_pos, rx497_eos, rxscan498_done
+    set rx495_pos, $P10
+    ge rx495_pos, rx495_eos, rxscan498_done
   rxscan498_scan:
     set_addr $I10, rxscan498_loop
-    rx497_cur."!mark_push"(0, rx497_pos, $I10)
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
   rxscan498_done:
-  # rx literal  ">"
-    add $I11, rx497_pos, 1
-    gt $I11, rx497_eos, rx497_fail
-    sub $I11, rx497_pos, rx497_off
-    substr $S10, rx497_tgt, $I11, 1
-    ne $S10, ">", rx497_fail
-    add rx497_pos, 1
-  # rx pass
-    rx497_cur."!cursor_pass"(rx497_pos, "")
-    rx497_cur."!cursor_debug"("PASS  ", "", " at pos=", rx497_pos)
-    .return (rx497_cur)
-  rx497_fail:
-    (rx497_rep, rx497_pos, $I10, $P10) = rx497_cur."!mark_fail"(0)
-    lt rx497_pos, -1, rx497_done
-    eq rx497_pos, -1, rx497_fail
-    jump $I10
-  rx497_done:
-    rx497_cur."!cursor_fail"()
-    rx497_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx497_cur)
-    .return ()
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "assertion:sym<[>"  :subid("140_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .const 'Sub' $P506 = "142_1278500530.77787" 
-    capture_lex $P506
-    .local string rx501_tgt
-    .local int rx501_pos
-    .local int rx501_off
-    .local int rx501_eos
-    .local int rx501_rep
-    .local pmc rx501_cur
-    (rx501_cur, rx501_pos, rx501_tgt) = self."!cursor_start"()
-    rx501_cur."!cursor_debug"("START ", "assertion:sym<[>")
-    rx501_cur."!cursor_caparray"("cclass_elem")
-    .lex unicode:"$\x{a2}", rx501_cur
-    .local pmc match
-    .lex "$/", match
-    length rx501_eos, rx501_tgt
-    gt rx501_pos, rx501_eos, rx501_done
-    set rx501_off, 0
-    lt rx501_pos, 2, rx501_start
-    sub rx501_off, rx501_pos, 1
-    substr rx501_tgt, rx501_tgt, rx501_off
-  rx501_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan504_done
-    goto rxscan504_scan
-  rxscan504_loop:
-    ($P10) = rx501_cur."from"()
-    inc $P10
-    set rx501_pos, $P10
-    ge rx501_pos, rx501_eos, rxscan504_done
-  rxscan504_scan:
-    set_addr $I10, rxscan504_loop
-    rx501_cur."!mark_push"(0, rx501_pos, $I10)
-  rxscan504_done:
-.annotate 'line', 160
-  # rx subrule "before" subtype=zerowidth negate=
-    rx501_cur."!cursor_pos"(rx501_pos)
-    .const 'Sub' $P506 = "142_1278500530.77787" 
+.annotate 'line', 163
+  # rx subcapture "sign"
+    set_addr $I10, rxcap_500_fail
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  alt499_0:
+    set_addr $I10, alt499_1
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  # rx literal  "+"
+    add $I11, rx495_pos, 1
+    gt $I11, rx495_eos, rx495_fail
+    sub $I11, rx495_pos, rx495_off
+    substr $S10, rx495_tgt, $I11, 1
+    ne $S10, "+", rx495_fail
+    add rx495_pos, 1
+    goto alt499_end
+  alt499_1:
+    set_addr $I10, alt499_2
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  # rx literal  "-"
+    add $I11, rx495_pos, 1
+    gt $I11, rx495_eos, rx495_fail
+    sub $I11, rx495_pos, rx495_off
+    substr $S10, rx495_tgt, $I11, 1
+    ne $S10, "-", rx495_fail
+    add rx495_pos, 1
+    goto alt499_end
+  alt499_2:
+  alt499_end:
+    set_addr $I10, rxcap_500_fail
+    ($I12, $I11) = rx495_cur."!mark_peek"($I10)
+    rx495_cur."!cursor_pos"($I11)
+    ($P10) = rx495_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx495_pos, "")
+    rx495_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("sign")
+    goto rxcap_500_done
+  rxcap_500_fail:
+    goto rx495_fail
+  rxcap_500_done:
+.annotate 'line', 164
+  # rx rxquantr501 ** 0..1
+    set_addr $I10, rxquantr501_done
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  rxquantr501_loop:
+  # rx subrule "normspace" subtype=method negate=
+    rx495_cur."!cursor_pos"(rx495_pos)
+    $P10 = rx495_cur."normspace"()
+    unless $P10, rx495_fail
+    goto rxsubrule502_pass
+  rxsubrule502_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx495_fail
+  rxsubrule502_pass:
+    set_addr $I10, rxsubrule502_back
+    rx495_cur."!mark_push"(0, rx495_pos, $I10, $P10)
+    rx495_pos = $P10."pos"()
+    set_addr $I10, rxquantr501_done
+    (rx495_rep) = rx495_cur."!mark_commit"($I10)
+  rxquantr501_done:
+  alt503_0:
+.annotate 'line', 165
+    set_addr $I10, alt503_1
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+.annotate 'line', 166
+  # rx literal  "["
+    add $I11, rx495_pos, 1
+    gt $I11, rx495_eos, rx495_fail
+    sub $I11, rx495_pos, rx495_off
+    substr $S10, rx495_tgt, $I11, 1
+    ne $S10, "[", rx495_fail
+    add rx495_pos, 1
+.annotate 'line', 169
+  # rx rxquantr504 ** 0..*
+    set_addr $I10, rxquantr504_done
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  rxquantr504_loop:
+.annotate 'line', 166
+  # rx subrule $P506 subtype=capture negate=
+    rx495_cur."!cursor_pos"(rx495_pos)
+    .const 'Sub' $P506 = "145_1279529218.55263" 
     capture_lex $P506
-    $P10 = rx501_cur."before"($P506)
-    unless $P10, rx501_fail
-  # rx rxquantr510 ** 1..*
-    set_addr $I511, rxquantr510_done
-    rx501_cur."!mark_push"(0, -1, $I511)
-  rxquantr510_loop:
-  # rx subrule "cclass_elem" subtype=capture negate=
-    rx501_cur."!cursor_pos"(rx501_pos)
-    $P10 = rx501_cur."cclass_elem"()
-    unless $P10, rx501_fail
-    rx501_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("cclass_elem")
-    rx501_pos = $P10."pos"()
-    (rx501_rep) = rx501_cur."!mark_commit"($I511)
-    rx501_cur."!mark_push"(rx501_rep, rx501_pos, $I511)
-    goto rxquantr510_loop
-  rxquantr510_done:
+    $P10 = rx495_cur.$P506()
+    unless $P10, rx495_fail
+    goto rxsubrule524_pass
+  rxsubrule524_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx495_fail
+  rxsubrule524_pass:
+    set_addr $I10, rxsubrule524_back
+    rx495_cur."!mark_push"(0, rx495_pos, $I10, $P10)
+    $P10."!cursor_names"("charspec")
+    rx495_pos = $P10."pos"()
+.annotate 'line', 169
+    set_addr $I10, rxquantr504_done
+    (rx495_rep) = rx495_cur."!mark_commit"($I10)
+    set_addr $I10, rxquantr504_done
+    rx495_cur."!mark_push"(rx495_rep, rx495_pos, $I10)
+    goto rxquantr504_loop
+  rxquantr504_done:
+.annotate 'line', 170
+  # rx charclass_q s r 0..-1
+    sub $I10, rx495_pos, rx495_off
+    find_not_cclass $I11, 32, rx495_tgt, $I10, rx495_eos
+    add rx495_pos, rx495_off, $I11
+  # rx literal  "]"
+    add $I11, rx495_pos, 1
+    gt $I11, rx495_eos, rx495_fail
+    sub $I11, rx495_pos, rx495_off
+    substr $S10, rx495_tgt, $I11, 1
+    ne $S10, "]", rx495_fail
+    add rx495_pos, 1
+.annotate 'line', 166
+    goto alt503_end
+  alt503_1:
+.annotate 'line', 171
+  # rx subcapture "name"
+    set_addr $I10, rxcap_525_fail
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  # rx charclass_q w r 1..-1
+    sub $I10, rx495_pos, rx495_off
+    find_not_cclass $I11, 8192, rx495_tgt, $I10, rx495_eos
+    add $I12, $I10, 1
+    lt $I11, $I12, rx495_fail
+    add rx495_pos, rx495_off, $I11
+    set_addr $I10, rxcap_525_fail
+    ($I12, $I11) = rx495_cur."!mark_peek"($I10)
+    rx495_cur."!cursor_pos"($I11)
+    ($P10) = rx495_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx495_pos, "")
+    rx495_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("name")
+    goto rxcap_525_done
+  rxcap_525_fail:
+    goto rx495_fail
+  rxcap_525_done:
+  alt503_end:
+.annotate 'line', 173
+  # rx rxquantr526 ** 0..1
+    set_addr $I10, rxquantr526_done
+    rx495_cur."!mark_push"(0, rx495_pos, $I10)
+  rxquantr526_loop:
+  # rx subrule "normspace" subtype=method negate=
+    rx495_cur."!cursor_pos"(rx495_pos)
+    $P10 = rx495_cur."normspace"()
+    unless $P10, rx495_fail
+    goto rxsubrule527_pass
+  rxsubrule527_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx495_fail
+  rxsubrule527_pass:
+    set_addr $I10, rxsubrule527_back
+    rx495_cur."!mark_push"(0, rx495_pos, $I10, $P10)
+    rx495_pos = $P10."pos"()
+    set_addr $I10, rxquantr526_done
+    (rx495_rep) = rx495_cur."!mark_commit"($I10)
+  rxquantr526_done:
+.annotate 'line', 162
   # rx pass
-    rx501_cur."!cursor_pass"(rx501_pos, "assertion:sym<[>")
-    rx501_cur."!cursor_debug"("PASS  ", "assertion:sym<[>", " at pos=", rx501_pos)
-    .return (rx501_cur)
-  rx501_fail:
+    rx495_cur."!cursor_pass"(rx495_pos, "cclass_elem")
+    rx495_cur."!cursor_debug"("PASS  ", "cclass_elem", " at pos=", rx495_pos)
+    .return (rx495_cur)
+  rx495_restart:
 .annotate 'line', 3
-    (rx501_rep, rx501_pos, $I10, $P10) = rx501_cur."!mark_fail"(0)
-    lt rx501_pos, -1, rx501_done
-    eq rx501_pos, -1, rx501_fail
+    rx495_cur."!cursor_debug"("NEXT ", "cclass_elem")
+  rx495_fail:
+    (rx495_rep, rx495_pos, $I10, $P10) = rx495_cur."!mark_fail"(0)
+    lt rx495_pos, -1, rx495_done
+    eq rx495_pos, -1, rx495_fail
     jump $I10
-  rx501_done:
-    rx501_cur."!cursor_fail"()
-    rx501_cur."!cursor_debug"("FAIL  ", "assertion:sym<[>")
-    .return (rx501_cur)
+  rx495_done:
+    rx495_cur."!cursor_fail"()
+    rx495_cur."!cursor_debug"("FAIL  ", "cclass_elem")
+    .return (rx495_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__assertion:sym<[>"  :subid("141_1278500530.77787") :method
+.sub "!PREFIX__cclass_elem"  :subid("144_1279529218.55263") :method
 .annotate 'line', 3
-    new $P503, "ResizablePMCArray"
-    push $P503, ""
-    .return ($P503)
+    new $P497, "ResizablePMCArray"
+    push $P497, ""
+    push $P497, "-"
+    push $P497, "+"
+    .return ($P497)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block505"  :anon :subid("142_1278500530.77787") :method :outer("140_1278500530.77787")
-.annotate 'line', 160
+.sub "_block505"  :anon :subid("145_1279529218.55263") :method :outer("143_1279529218.55263")
+.annotate 'line', 166
+    .const 'Sub' $P521 = "148_1279529218.55263" 
+    capture_lex $P521
+    .const 'Sub' $P516 = "147_1279529218.55263" 
+    capture_lex $P516
+    .const 'Sub' $P512 = "146_1279529218.55263" 
+    capture_lex $P512
     .local string rx507_tgt
     .local int rx507_pos
     .local int rx507_off
     .local int rx507_eos
     .local int rx507_rep
     .local pmc rx507_cur
-    (rx507_cur, rx507_pos, rx507_tgt) = self."!cursor_start"()
-    rx507_cur."!cursor_debug"("START ", "")
+    (rx507_cur, rx507_pos, rx507_tgt, $I10) = self."!cursor_start"()
+    rx507_cur."!cursor_caparray"("1")
     .lex unicode:"$\x{a2}", rx507_cur
     .local pmc match
     .lex "$/", match
@@ -6235,6 +6798,8 @@
     sub rx507_off, rx507_pos, 1
     substr rx507_tgt, rx507_tgt, rx507_off
   rx507_start:
+    eq $I10, 1, rx507_restart
+    rx507_cur."!cursor_debug"("START ", "")
     $I10 = self.'from'()
     ne $I10, -1, rxscan508_done
     goto rxscan508_scan
@@ -6250,38 +6815,100 @@
   alt509_0:
     set_addr $I10, alt509_1
     rx507_cur."!mark_push"(0, rx507_pos, $I10)
-  # rx literal  "["
+.annotate 'line', 167
+  # rx charclass_q s r 0..-1
+    sub $I10, rx507_pos, rx507_off
+    find_not_cclass $I11, 32, rx507_tgt, $I10, rx507_eos
+    add rx507_pos, rx507_off, $I11
+  # rx literal  "-"
     add $I11, rx507_pos, 1
     gt $I11, rx507_eos, rx507_fail
     sub $I11, rx507_pos, rx507_off
     substr $S10, rx507_tgt, $I11, 1
-    ne $S10, "[", rx507_fail
+    ne $S10, "-", rx507_fail
     add rx507_pos, 1
+  # rx subrule "obs" subtype=method negate=
+    rx507_cur."!cursor_pos"(rx507_pos)
+    $P10 = rx507_cur."obs"("hyphen in enumerated character class", "..")
+    unless $P10, rx507_fail
+    rx507_pos = $P10."pos"()
     goto alt509_end
   alt509_1:
-    set_addr $I10, alt509_2
+.annotate 'line', 168
+  # rx charclass_q s r 0..-1
+    sub $I10, rx507_pos, rx507_off
+    find_not_cclass $I11, 32, rx507_tgt, $I10, rx507_eos
+    add rx507_pos, rx507_off, $I11
+  alt510_0:
+    set_addr $I10, alt510_1
     rx507_cur."!mark_push"(0, rx507_pos, $I10)
-  # rx literal  "+"
+  # rx literal  "\\"
     add $I11, rx507_pos, 1
     gt $I11, rx507_eos, rx507_fail
     sub $I11, rx507_pos, rx507_off
     substr $S10, rx507_tgt, $I11, 1
-    ne $S10, "+", rx507_fail
+    ne $S10, "\\", rx507_fail
     add rx507_pos, 1
-    goto alt509_end
-  alt509_2:
-  # rx literal  "-"
-    add $I11, rx507_pos, 1
+  # rx subrule $P512 subtype=capture negate=
+    rx507_cur."!cursor_pos"(rx507_pos)
+    .const 'Sub' $P512 = "146_1279529218.55263" 
+    capture_lex $P512
+    $P10 = rx507_cur.$P512()
+    unless $P10, rx507_fail
+    rx507_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"(0)
+    rx507_pos = $P10."pos"()
+    goto alt510_end
+  alt510_1:
+  # rx subrule $P516 subtype=capture negate=
+    rx507_cur."!cursor_pos"(rx507_pos)
+    .const 'Sub' $P516 = "147_1279529218.55263" 
+    capture_lex $P516
+    $P10 = rx507_cur.$P516()
+    unless $P10, rx507_fail
+    rx507_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"(0)
+    rx507_pos = $P10."pos"()
+  alt510_end:
+  # rx rxquantr519 ** 0..1
+    set_addr $I10, rxquantr519_done
+    rx507_cur."!mark_push"(0, rx507_pos, $I10)
+  rxquantr519_loop:
+  # rx charclass_q s r 0..-1
+    sub $I10, rx507_pos, rx507_off
+    find_not_cclass $I11, 32, rx507_tgt, $I10, rx507_eos
+    add rx507_pos, rx507_off, $I11
+  # rx literal  ".."
+    add $I11, rx507_pos, 2
     gt $I11, rx507_eos, rx507_fail
     sub $I11, rx507_pos, rx507_off
-    substr $S10, rx507_tgt, $I11, 1
-    ne $S10, "-", rx507_fail
-    add rx507_pos, 1
+    substr $S10, rx507_tgt, $I11, 2
+    ne $S10, "..", rx507_fail
+    add rx507_pos, 2
+  # rx charclass_q s r 0..-1
+    sub $I10, rx507_pos, rx507_off
+    find_not_cclass $I11, 32, rx507_tgt, $I10, rx507_eos
+    add rx507_pos, rx507_off, $I11
+  # rx subrule $P521 subtype=capture negate=
+    rx507_cur."!cursor_pos"(rx507_pos)
+    .const 'Sub' $P521 = "148_1279529218.55263" 
+    capture_lex $P521
+    $P10 = rx507_cur.$P521()
+    unless $P10, rx507_fail
+    rx507_cur."!mark_push"(0, -1, 0, $P10)
+    $P10."!cursor_names"("1")
+    rx507_pos = $P10."pos"()
+    set_addr $I10, rxquantr519_done
+    (rx507_rep) = rx507_cur."!mark_commit"($I10)
+  rxquantr519_done:
   alt509_end:
+.annotate 'line', 166
   # rx pass
     rx507_cur."!cursor_pass"(rx507_pos, "")
     rx507_cur."!cursor_debug"("PASS  ", "", " at pos=", rx507_pos)
     .return (rx507_cur)
+  rx507_restart:
+    rx507_cur."!cursor_debug"("NEXT ", "")
   rx507_fail:
     (rx507_rep, rx507_pos, $I10, $P10) = rx507_cur."!mark_fail"(0)
     lt rx507_pos, -1, rx507_done
@@ -6296,19 +6923,15 @@
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "cclass_elem"  :subid("143_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .const 'Sub' $P524 = "145_1278500530.77787" 
-    capture_lex $P524
+.sub "_block511"  :anon :subid("146_1279529218.55263") :method :outer("145_1279529218.55263")
+.annotate 'line', 168
     .local string rx513_tgt
     .local int rx513_pos
     .local int rx513_off
     .local int rx513_eos
     .local int rx513_rep
     .local pmc rx513_cur
-    (rx513_cur, rx513_pos, rx513_tgt) = self."!cursor_start"()
-    rx513_cur."!cursor_debug"("START ", "cclass_elem")
-    rx513_cur."!cursor_caparray"("charspec")
+    (rx513_cur, rx513_pos, rx513_tgt, $I10) = self."!cursor_start"()
     .lex unicode:"$\x{a2}", rx513_cur
     .local pmc match
     .lex "$/", match
@@ -6319,1047 +6942,741 @@
     sub rx513_off, rx513_pos, 1
     substr rx513_tgt, rx513_tgt, rx513_off
   rx513_start:
+    eq $I10, 1, rx513_restart
+    rx513_cur."!cursor_debug"("START ", "")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan516_done
-    goto rxscan516_scan
-  rxscan516_loop:
+    ne $I10, -1, rxscan514_done
+    goto rxscan514_scan
+  rxscan514_loop:
     ($P10) = rx513_cur."from"()
     inc $P10
     set rx513_pos, $P10
-    ge rx513_pos, rx513_eos, rxscan516_done
-  rxscan516_scan:
-    set_addr $I10, rxscan516_loop
+    ge rx513_pos, rx513_eos, rxscan514_done
+  rxscan514_scan:
+    set_addr $I10, rxscan514_loop
     rx513_cur."!mark_push"(0, rx513_pos, $I10)
-  rxscan516_done:
-.annotate 'line', 163
-  # rx subcapture "sign"
-    set_addr $I10, rxcap_518_fail
-    rx513_cur."!mark_push"(0, rx513_pos, $I10)
-  alt517_0:
-    set_addr $I10, alt517_1
-    rx513_cur."!mark_push"(0, rx513_pos, $I10)
-  # rx literal  "+"
-    add $I11, rx513_pos, 1
-    gt $I11, rx513_eos, rx513_fail
-    sub $I11, rx513_pos, rx513_off
-    substr $S10, rx513_tgt, $I11, 1
-    ne $S10, "+", rx513_fail
-    add rx513_pos, 1
-    goto alt517_end
-  alt517_1:
-    set_addr $I10, alt517_2
-    rx513_cur."!mark_push"(0, rx513_pos, $I10)
-  # rx literal  "-"
-    add $I11, rx513_pos, 1
-    gt $I11, rx513_eos, rx513_fail
-    sub $I11, rx513_pos, rx513_off
-    substr $S10, rx513_tgt, $I11, 1
-    ne $S10, "-", rx513_fail
-    add rx513_pos, 1
-    goto alt517_end
-  alt517_2:
-  alt517_end:
-    set_addr $I10, rxcap_518_fail
-    ($I12, $I11) = rx513_cur."!mark_peek"($I10)
-    rx513_cur."!cursor_pos"($I11)
-    ($P10) = rx513_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx513_pos, "")
-    rx513_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("sign")
-    goto rxcap_518_done
-  rxcap_518_fail:
-    goto rx513_fail
-  rxcap_518_done:
-.annotate 'line', 164
-  # rx rxquantr519 ** 0..1
-    set_addr $I520, rxquantr519_done
-    rx513_cur."!mark_push"(0, rx513_pos, $I520)
-  rxquantr519_loop:
-  # rx subrule "normspace" subtype=method negate=
-    rx513_cur."!cursor_pos"(rx513_pos)
-    $P10 = rx513_cur."normspace"()
-    unless $P10, rx513_fail
-    rx513_pos = $P10."pos"()
-    (rx513_rep) = rx513_cur."!mark_commit"($I520)
-  rxquantr519_done:
-  alt521_0:
-.annotate 'line', 165
-    set_addr $I10, alt521_1
-    rx513_cur."!mark_push"(0, rx513_pos, $I10)
-.annotate 'line', 166
-  # rx literal  "["
-    add $I11, rx513_pos, 1
-    gt $I11, rx513_eos, rx513_fail
-    sub $I11, rx513_pos, rx513_off
-    substr $S10, rx513_tgt, $I11, 1
-    ne $S10, "[", rx513_fail
-    add rx513_pos, 1
-.annotate 'line', 169
-  # rx rxquantr522 ** 0..*
-    set_addr $I543, rxquantr522_done
-    rx513_cur."!mark_push"(0, rx513_pos, $I543)
-  rxquantr522_loop:
-.annotate 'line', 166
-  # rx subrule $P524 subtype=capture negate=
-    rx513_cur."!cursor_pos"(rx513_pos)
-    .const 'Sub' $P524 = "145_1278500530.77787" 
-    capture_lex $P524
-    $P10 = rx513_cur.$P524()
-    unless $P10, rx513_fail
-    rx513_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("charspec")
-    rx513_pos = $P10."pos"()
-.annotate 'line', 169
-    (rx513_rep) = rx513_cur."!mark_commit"($I543)
-    rx513_cur."!mark_push"(rx513_rep, rx513_pos, $I543)
-    goto rxquantr522_loop
-  rxquantr522_done:
-.annotate 'line', 170
-  # rx charclass_q s r 0..-1
-    sub $I10, rx513_pos, rx513_off
-    find_not_cclass $I11, 32, rx513_tgt, $I10, rx513_eos
-    add rx513_pos, rx513_off, $I11
-  # rx literal  "]"
-    add $I11, rx513_pos, 1
-    gt $I11, rx513_eos, rx513_fail
-    sub $I11, rx513_pos, rx513_off
-    substr $S10, rx513_tgt, $I11, 1
-    ne $S10, "]", rx513_fail
-    add rx513_pos, 1
-.annotate 'line', 166
-    goto alt521_end
-  alt521_1:
-.annotate 'line', 171
-  # rx subcapture "name"
-    set_addr $I10, rxcap_544_fail
-    rx513_cur."!mark_push"(0, rx513_pos, $I10)
-  # rx charclass_q w r 1..-1
-    sub $I10, rx513_pos, rx513_off
-    find_not_cclass $I11, 8192, rx513_tgt, $I10, rx513_eos
-    add $I12, $I10, 1
-    lt $I11, $I12, rx513_fail
-    add rx513_pos, rx513_off, $I11
-    set_addr $I10, rxcap_544_fail
-    ($I12, $I11) = rx513_cur."!mark_peek"($I10)
-    rx513_cur."!cursor_pos"($I11)
-    ($P10) = rx513_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx513_pos, "")
-    rx513_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("name")
-    goto rxcap_544_done
-  rxcap_544_fail:
-    goto rx513_fail
-  rxcap_544_done:
-  alt521_end:
-.annotate 'line', 173
-  # rx rxquantr545 ** 0..1
-    set_addr $I546, rxquantr545_done
-    rx513_cur."!mark_push"(0, rx513_pos, $I546)
-  rxquantr545_loop:
-  # rx subrule "normspace" subtype=method negate=
-    rx513_cur."!cursor_pos"(rx513_pos)
-    $P10 = rx513_cur."normspace"()
-    unless $P10, rx513_fail
-    rx513_pos = $P10."pos"()
-    (rx513_rep) = rx513_cur."!mark_commit"($I546)
-  rxquantr545_done:
-.annotate 'line', 162
+  rxscan514_done:
+  # rx charclass .
+    ge rx513_pos, rx513_eos, rx513_fail
+    inc rx513_pos
   # rx pass
-    rx513_cur."!cursor_pass"(rx513_pos, "cclass_elem")
-    rx513_cur."!cursor_debug"("PASS  ", "cclass_elem", " at pos=", rx513_pos)
+    rx513_cur."!cursor_pass"(rx513_pos, "")
+    rx513_cur."!cursor_debug"("PASS  ", "", " at pos=", rx513_pos)
     .return (rx513_cur)
+  rx513_restart:
+    rx513_cur."!cursor_debug"("NEXT ", "")
   rx513_fail:
-.annotate 'line', 3
     (rx513_rep, rx513_pos, $I10, $P10) = rx513_cur."!mark_fail"(0)
     lt rx513_pos, -1, rx513_done
     eq rx513_pos, -1, rx513_fail
     jump $I10
   rx513_done:
     rx513_cur."!cursor_fail"()
-    rx513_cur."!cursor_debug"("FAIL  ", "cclass_elem")
+    rx513_cur."!cursor_debug"("FAIL  ", "")
     .return (rx513_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__cclass_elem"  :subid("144_1278500530.77787") :method
-.annotate 'line', 3
-    new $P515, "ResizablePMCArray"
-    push $P515, ""
-    push $P515, "-"
-    push $P515, "+"
-    .return ($P515)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block523"  :anon :subid("145_1278500530.77787") :method :outer("143_1278500530.77787")
-.annotate 'line', 166
-    .const 'Sub' $P539 = "148_1278500530.77787" 
-    capture_lex $P539
-    .const 'Sub' $P534 = "147_1278500530.77787" 
-    capture_lex $P534
-    .const 'Sub' $P530 = "146_1278500530.77787" 
-    capture_lex $P530
-    .local string rx525_tgt
-    .local int rx525_pos
-    .local int rx525_off
-    .local int rx525_eos
-    .local int rx525_rep
-    .local pmc rx525_cur
-    (rx525_cur, rx525_pos, rx525_tgt) = self."!cursor_start"()
-    rx525_cur."!cursor_debug"("START ", "")
-    rx525_cur."!cursor_caparray"("1")
-    .lex unicode:"$\x{a2}", rx525_cur
-    .local pmc match
-    .lex "$/", match
-    length rx525_eos, rx525_tgt
-    gt rx525_pos, rx525_eos, rx525_done
-    set rx525_off, 0
-    lt rx525_pos, 2, rx525_start
-    sub rx525_off, rx525_pos, 1
-    substr rx525_tgt, rx525_tgt, rx525_off
-  rx525_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan526_done
-    goto rxscan526_scan
-  rxscan526_loop:
-    ($P10) = rx525_cur."from"()
-    inc $P10
-    set rx525_pos, $P10
-    ge rx525_pos, rx525_eos, rxscan526_done
-  rxscan526_scan:
-    set_addr $I10, rxscan526_loop
-    rx525_cur."!mark_push"(0, rx525_pos, $I10)
-  rxscan526_done:
-  alt527_0:
-    set_addr $I10, alt527_1
-    rx525_cur."!mark_push"(0, rx525_pos, $I10)
-.annotate 'line', 167
-  # rx charclass_q s r 0..-1
-    sub $I10, rx525_pos, rx525_off
-    find_not_cclass $I11, 32, rx525_tgt, $I10, rx525_eos
-    add rx525_pos, rx525_off, $I11
-  # rx literal  "-"
-    add $I11, rx525_pos, 1
-    gt $I11, rx525_eos, rx525_fail
-    sub $I11, rx525_pos, rx525_off
-    substr $S10, rx525_tgt, $I11, 1
-    ne $S10, "-", rx525_fail
-    add rx525_pos, 1
-  # rx subrule "obs" subtype=method negate=
-    rx525_cur."!cursor_pos"(rx525_pos)
-    $P10 = rx525_cur."obs"("hyphen in enumerated character class", "..")
-    unless $P10, rx525_fail
-    rx525_pos = $P10."pos"()
-    goto alt527_end
-  alt527_1:
-.annotate 'line', 168
-  # rx charclass_q s r 0..-1
-    sub $I10, rx525_pos, rx525_off
-    find_not_cclass $I11, 32, rx525_tgt, $I10, rx525_eos
-    add rx525_pos, rx525_off, $I11
-  alt528_0:
-    set_addr $I10, alt528_1
-    rx525_cur."!mark_push"(0, rx525_pos, $I10)
-  # rx literal  "\\"
-    add $I11, rx525_pos, 1
-    gt $I11, rx525_eos, rx525_fail
-    sub $I11, rx525_pos, rx525_off
-    substr $S10, rx525_tgt, $I11, 1
-    ne $S10, "\\", rx525_fail
-    add rx525_pos, 1
-  # rx subrule $P530 subtype=capture negate=
-    rx525_cur."!cursor_pos"(rx525_pos)
-    .const 'Sub' $P530 = "146_1278500530.77787" 
-    capture_lex $P530
-    $P10 = rx525_cur.$P530()
-    unless $P10, rx525_fail
-    rx525_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"(0)
-    rx525_pos = $P10."pos"()
-    goto alt528_end
-  alt528_1:
-  # rx subrule $P534 subtype=capture negate=
-    rx525_cur."!cursor_pos"(rx525_pos)
-    .const 'Sub' $P534 = "147_1278500530.77787" 
-    capture_lex $P534
-    $P10 = rx525_cur.$P534()
-    unless $P10, rx525_fail
-    rx525_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"(0)
-    rx525_pos = $P10."pos"()
-  alt528_end:
-  # rx rxquantr537 ** 0..1
-    set_addr $I542, rxquantr537_done
-    rx525_cur."!mark_push"(0, rx525_pos, $I542)
-  rxquantr537_loop:
-  # rx charclass_q s r 0..-1
-    sub $I10, rx525_pos, rx525_off
-    find_not_cclass $I11, 32, rx525_tgt, $I10, rx525_eos
-    add rx525_pos, rx525_off, $I11
-  # rx literal  ".."
-    add $I11, rx525_pos, 2
-    gt $I11, rx525_eos, rx525_fail
-    sub $I11, rx525_pos, rx525_off
-    substr $S10, rx525_tgt, $I11, 2
-    ne $S10, "..", rx525_fail
-    add rx525_pos, 2
-  # rx charclass_q s r 0..-1
-    sub $I10, rx525_pos, rx525_off
-    find_not_cclass $I11, 32, rx525_tgt, $I10, rx525_eos
-    add rx525_pos, rx525_off, $I11
-  # rx subrule $P539 subtype=capture negate=
-    rx525_cur."!cursor_pos"(rx525_pos)
-    .const 'Sub' $P539 = "148_1278500530.77787" 
-    capture_lex $P539
-    $P10 = rx525_cur.$P539()
-    unless $P10, rx525_fail
-    rx525_cur."!mark_push"(0, -1, 0, $P10)
-    $P10."!cursor_names"("1")
-    rx525_pos = $P10."pos"()
-    (rx525_rep) = rx525_cur."!mark_commit"($I542)
-  rxquantr537_done:
-  alt527_end:
-.annotate 'line', 166
-  # rx pass
-    rx525_cur."!cursor_pass"(rx525_pos, "")
-    rx525_cur."!cursor_debug"("PASS  ", "", " at pos=", rx525_pos)
-    .return (rx525_cur)
-  rx525_fail:
-    (rx525_rep, rx525_pos, $I10, $P10) = rx525_cur."!mark_fail"(0)
-    lt rx525_pos, -1, rx525_done
-    eq rx525_pos, -1, rx525_fail
-    jump $I10
-  rx525_done:
-    rx525_cur."!cursor_fail"()
-    rx525_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx525_cur)
-    .return ()
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block529"  :anon :subid("146_1278500530.77787") :method :outer("145_1278500530.77787")
-.annotate 'line', 168
-    .local string rx531_tgt
-    .local int rx531_pos
-    .local int rx531_off
-    .local int rx531_eos
-    .local int rx531_rep
-    .local pmc rx531_cur
-    (rx531_cur, rx531_pos, rx531_tgt) = self."!cursor_start"()
-    rx531_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx531_cur
-    .local pmc match
-    .lex "$/", match
-    length rx531_eos, rx531_tgt
-    gt rx531_pos, rx531_eos, rx531_done
-    set rx531_off, 0
-    lt rx531_pos, 2, rx531_start
-    sub rx531_off, rx531_pos, 1
-    substr rx531_tgt, rx531_tgt, rx531_off
-  rx531_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan532_done
-    goto rxscan532_scan
-  rxscan532_loop:
-    ($P10) = rx531_cur."from"()
-    inc $P10
-    set rx531_pos, $P10
-    ge rx531_pos, rx531_eos, rxscan532_done
-  rxscan532_scan:
-    set_addr $I10, rxscan532_loop
-    rx531_cur."!mark_push"(0, rx531_pos, $I10)
-  rxscan532_done:
-  # rx charclass .
-    ge rx531_pos, rx531_eos, rx531_fail
-    inc rx531_pos
-  # rx pass
-    rx531_cur."!cursor_pass"(rx531_pos, "")
-    rx531_cur."!cursor_debug"("PASS  ", "", " at pos=", rx531_pos)
-    .return (rx531_cur)
-  rx531_fail:
-    (rx531_rep, rx531_pos, $I10, $P10) = rx531_cur."!mark_fail"(0)
-    lt rx531_pos, -1, rx531_done
-    eq rx531_pos, -1, rx531_fail
-    jump $I10
-  rx531_done:
-    rx531_cur."!cursor_fail"()
-    rx531_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx531_cur)
-    .return ()
-.end
-
-
-.namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block533"  :anon :subid("147_1278500530.77787") :method :outer("145_1278500530.77787")
+.sub "_block515"  :anon :subid("147_1279529218.55263") :method :outer("145_1279529218.55263")
 .annotate 'line', 168
-    .local string rx535_tgt
-    .local int rx535_pos
-    .local int rx535_off
-    .local int rx535_eos
-    .local int rx535_rep
-    .local pmc rx535_cur
-    (rx535_cur, rx535_pos, rx535_tgt) = self."!cursor_start"()
-    rx535_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx535_cur
-    .local pmc match
-    .lex "$/", match
-    length rx535_eos, rx535_tgt
-    gt rx535_pos, rx535_eos, rx535_done
-    set rx535_off, 0
-    lt rx535_pos, 2, rx535_start
-    sub rx535_off, rx535_pos, 1
-    substr rx535_tgt, rx535_tgt, rx535_off
-  rx535_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan536_done
-    goto rxscan536_scan
-  rxscan536_loop:
-    ($P10) = rx535_cur."from"()
-    inc $P10
-    set rx535_pos, $P10
-    ge rx535_pos, rx535_eos, rxscan536_done
-  rxscan536_scan:
-    set_addr $I10, rxscan536_loop
-    rx535_cur."!mark_push"(0, rx535_pos, $I10)
-  rxscan536_done:
+    .local string rx517_tgt
+    .local int rx517_pos
+    .local int rx517_off
+    .local int rx517_eos
+    .local int rx517_rep
+    .local pmc rx517_cur
+    (rx517_cur, rx517_pos, rx517_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx517_cur
+    .local pmc match
+    .lex "$/", match
+    length rx517_eos, rx517_tgt
+    gt rx517_pos, rx517_eos, rx517_done
+    set rx517_off, 0
+    lt rx517_pos, 2, rx517_start
+    sub rx517_off, rx517_pos, 1
+    substr rx517_tgt, rx517_tgt, rx517_off
+  rx517_start:
+    eq $I10, 1, rx517_restart
+    rx517_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan518_done
+    goto rxscan518_scan
+  rxscan518_loop:
+    ($P10) = rx517_cur."from"()
+    inc $P10
+    set rx517_pos, $P10
+    ge rx517_pos, rx517_eos, rxscan518_done
+  rxscan518_scan:
+    set_addr $I10, rxscan518_loop
+    rx517_cur."!mark_push"(0, rx517_pos, $I10)
+  rxscan518_done:
   # rx enumcharlist negate=1 
-    ge rx535_pos, rx535_eos, rx535_fail
-    sub $I10, rx535_pos, rx535_off
-    substr $S10, rx535_tgt, $I10, 1
+    ge rx517_pos, rx517_eos, rx517_fail
+    sub $I10, rx517_pos, rx517_off
+    substr $S10, rx517_tgt, $I10, 1
     index $I11, "]\\", $S10
-    ge $I11, 0, rx535_fail
-    inc rx535_pos
+    ge $I11, 0, rx517_fail
+    inc rx517_pos
   # rx pass
-    rx535_cur."!cursor_pass"(rx535_pos, "")
-    rx535_cur."!cursor_debug"("PASS  ", "", " at pos=", rx535_pos)
-    .return (rx535_cur)
-  rx535_fail:
-    (rx535_rep, rx535_pos, $I10, $P10) = rx535_cur."!mark_fail"(0)
-    lt rx535_pos, -1, rx535_done
-    eq rx535_pos, -1, rx535_fail
+    rx517_cur."!cursor_pass"(rx517_pos, "")
+    rx517_cur."!cursor_debug"("PASS  ", "", " at pos=", rx517_pos)
+    .return (rx517_cur)
+  rx517_restart:
+    rx517_cur."!cursor_debug"("NEXT ", "")
+  rx517_fail:
+    (rx517_rep, rx517_pos, $I10, $P10) = rx517_cur."!mark_fail"(0)
+    lt rx517_pos, -1, rx517_done
+    eq rx517_pos, -1, rx517_fail
     jump $I10
-  rx535_done:
-    rx535_cur."!cursor_fail"()
-    rx535_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx535_cur)
+  rx517_done:
+    rx517_cur."!cursor_fail"()
+    rx517_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx517_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block538"  :anon :subid("148_1278500530.77787") :method :outer("145_1278500530.77787")
+.sub "_block520"  :anon :subid("148_1279529218.55263") :method :outer("145_1279529218.55263")
 .annotate 'line', 168
-    .local string rx540_tgt
-    .local int rx540_pos
-    .local int rx540_off
-    .local int rx540_eos
-    .local int rx540_rep
-    .local pmc rx540_cur
-    (rx540_cur, rx540_pos, rx540_tgt) = self."!cursor_start"()
-    rx540_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx540_cur
-    .local pmc match
-    .lex "$/", match
-    length rx540_eos, rx540_tgt
-    gt rx540_pos, rx540_eos, rx540_done
-    set rx540_off, 0
-    lt rx540_pos, 2, rx540_start
-    sub rx540_off, rx540_pos, 1
-    substr rx540_tgt, rx540_tgt, rx540_off
-  rx540_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan541_done
-    goto rxscan541_scan
-  rxscan541_loop:
-    ($P10) = rx540_cur."from"()
-    inc $P10
-    set rx540_pos, $P10
-    ge rx540_pos, rx540_eos, rxscan541_done
-  rxscan541_scan:
-    set_addr $I10, rxscan541_loop
-    rx540_cur."!mark_push"(0, rx540_pos, $I10)
-  rxscan541_done:
+    .local string rx522_tgt
+    .local int rx522_pos
+    .local int rx522_off
+    .local int rx522_eos
+    .local int rx522_rep
+    .local pmc rx522_cur
+    (rx522_cur, rx522_pos, rx522_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx522_cur
+    .local pmc match
+    .lex "$/", match
+    length rx522_eos, rx522_tgt
+    gt rx522_pos, rx522_eos, rx522_done
+    set rx522_off, 0
+    lt rx522_pos, 2, rx522_start
+    sub rx522_off, rx522_pos, 1
+    substr rx522_tgt, rx522_tgt, rx522_off
+  rx522_start:
+    eq $I10, 1, rx522_restart
+    rx522_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan523_done
+    goto rxscan523_scan
+  rxscan523_loop:
+    ($P10) = rx522_cur."from"()
+    inc $P10
+    set rx522_pos, $P10
+    ge rx522_pos, rx522_eos, rxscan523_done
+  rxscan523_scan:
+    set_addr $I10, rxscan523_loop
+    rx522_cur."!mark_push"(0, rx522_pos, $I10)
+  rxscan523_done:
   # rx charclass .
-    ge rx540_pos, rx540_eos, rx540_fail
-    inc rx540_pos
+    ge rx522_pos, rx522_eos, rx522_fail
+    inc rx522_pos
   # rx pass
-    rx540_cur."!cursor_pass"(rx540_pos, "")
-    rx540_cur."!cursor_debug"("PASS  ", "", " at pos=", rx540_pos)
-    .return (rx540_cur)
-  rx540_fail:
-    (rx540_rep, rx540_pos, $I10, $P10) = rx540_cur."!mark_fail"(0)
-    lt rx540_pos, -1, rx540_done
-    eq rx540_pos, -1, rx540_fail
-    jump $I10
-  rx540_done:
-    rx540_cur."!cursor_fail"()
-    rx540_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx540_cur)
+    rx522_cur."!cursor_pass"(rx522_pos, "")
+    rx522_cur."!cursor_debug"("PASS  ", "", " at pos=", rx522_pos)
+    .return (rx522_cur)
+  rx522_restart:
+    rx522_cur."!cursor_debug"("NEXT ", "")
+  rx522_fail:
+    (rx522_rep, rx522_pos, $I10, $P10) = rx522_cur."!mark_fail"(0)
+    lt rx522_pos, -1, rx522_done
+    eq rx522_pos, -1, rx522_fail
+    jump $I10
+  rx522_done:
+    rx522_cur."!cursor_fail"()
+    rx522_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx522_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "mod_internal"  :subid("149_1278500530.77787") :method :outer("11_1278500530.77787")
-.annotate 'line', 3
-    .const 'Sub' $P556 = "151_1278500530.77787" 
-    capture_lex $P556
-    .local string rx548_tgt
-    .local int rx548_pos
-    .local int rx548_off
-    .local int rx548_eos
-    .local int rx548_rep
-    .local pmc rx548_cur
-    (rx548_cur, rx548_pos, rx548_tgt) = self."!cursor_start"()
-    rx548_cur."!cursor_debug"("START ", "mod_internal")
-    rx548_cur."!cursor_caparray"("n")
-    .lex unicode:"$\x{a2}", rx548_cur
-    .local pmc match
-    .lex "$/", match
-    length rx548_eos, rx548_tgt
-    gt rx548_pos, rx548_eos, rx548_done
-    set rx548_off, 0
-    lt rx548_pos, 2, rx548_start
-    sub rx548_off, rx548_pos, 1
-    substr rx548_tgt, rx548_tgt, rx548_off
-  rx548_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan552_done
-    goto rxscan552_scan
-  rxscan552_loop:
-    ($P10) = rx548_cur."from"()
-    inc $P10
-    set rx548_pos, $P10
-    ge rx548_pos, rx548_eos, rxscan552_done
-  rxscan552_scan:
-    set_addr $I10, rxscan552_loop
-    rx548_cur."!mark_push"(0, rx548_pos, $I10)
-  rxscan552_done:
-  alt553_0:
+.sub "mod_internal"  :subid("149_1279529218.55263") :method :outer("11_1279529218.55263")
+.annotate 'line', 3
+    .const 'Sub' $P537 = "151_1279529218.55263" 
+    capture_lex $P537
+    .local string rx529_tgt
+    .local int rx529_pos
+    .local int rx529_off
+    .local int rx529_eos
+    .local int rx529_rep
+    .local pmc rx529_cur
+    (rx529_cur, rx529_pos, rx529_tgt, $I10) = self."!cursor_start"()
+    rx529_cur."!cursor_caparray"("n")
+    .lex unicode:"$\x{a2}", rx529_cur
+    .local pmc match
+    .lex "$/", match
+    length rx529_eos, rx529_tgt
+    gt rx529_pos, rx529_eos, rx529_done
+    set rx529_off, 0
+    lt rx529_pos, 2, rx529_start
+    sub rx529_off, rx529_pos, 1
+    substr rx529_tgt, rx529_tgt, rx529_off
+  rx529_start:
+    eq $I10, 1, rx529_restart
+    rx529_cur."!cursor_debug"("START ", "mod_internal")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan533_done
+    goto rxscan533_scan
+  rxscan533_loop:
+    ($P10) = rx529_cur."from"()
+    inc $P10
+    set rx529_pos, $P10
+    ge rx529_pos, rx529_eos, rxscan533_done
+  rxscan533_scan:
+    set_addr $I10, rxscan533_loop
+    rx529_cur."!mark_push"(0, rx529_pos, $I10)
+  rxscan533_done:
+  alt534_0:
 .annotate 'line', 177
-    set_addr $I10, alt553_1
-    rx548_cur."!mark_push"(0, rx548_pos, $I10)
+    set_addr $I10, alt534_1
+    rx529_cur."!mark_push"(0, rx529_pos, $I10)
 .annotate 'line', 178
   # rx literal  ":"
-    add $I11, rx548_pos, 1
-    gt $I11, rx548_eos, rx548_fail
-    sub $I11, rx548_pos, rx548_off
-    substr $S10, rx548_tgt, $I11, 1
-    ne $S10, ":", rx548_fail
-    add rx548_pos, 1
-  # rx rxquantr554 ** 1..1
-    set_addr $I560, rxquantr554_done
-    rx548_cur."!mark_push"(0, -1, $I560)
-  rxquantr554_loop:
-  # rx subrule $P556 subtype=capture negate=
-    rx548_cur."!cursor_pos"(rx548_pos)
-    .const 'Sub' $P556 = "151_1278500530.77787" 
-    capture_lex $P556
-    $P10 = rx548_cur.$P556()
-    unless $P10, rx548_fail
-    rx548_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx529_pos, 1
+    gt $I11, rx529_eos, rx529_fail
+    sub $I11, rx529_pos, rx529_off
+    substr $S10, rx529_tgt, $I11, 1
+    ne $S10, ":", rx529_fail
+    add rx529_pos, 1
+  # rx rxquantr535 ** 1..1
+    set_addr $I10, rxquantr535_done
+    rx529_cur."!mark_push"(0, -1, $I10)
+  rxquantr535_loop:
+  # rx subrule $P537 subtype=capture negate=
+    rx529_cur."!cursor_pos"(rx529_pos)
+    .const 'Sub' $P537 = "151_1279529218.55263" 
+    capture_lex $P537
+    $P10 = rx529_cur.$P537()
+    unless $P10, rx529_fail
+    goto rxsubrule541_pass
+  rxsubrule541_back:
+    $P10 = $P10."!cursor_next"()
+    unless $P10, rx529_fail
+  rxsubrule541_pass:
+    set_addr $I10, rxsubrule541_back
+    rx529_cur."!mark_push"(0, rx529_pos, $I10, $P10)
     $P10."!cursor_names"("n")
-    rx548_pos = $P10."pos"()
-    (rx548_rep) = rx548_cur."!mark_commit"($I560)
-  rxquantr554_done:
+    rx529_pos = $P10."pos"()
+    set_addr $I10, rxquantr535_done
+    (rx529_rep) = rx529_cur."!mark_commit"($I10)
+  rxquantr535_done:
   # rx subrule "mod_ident" subtype=capture negate=
-    rx548_cur."!cursor_pos"(rx548_pos)
-    $P10 = rx548_cur."mod_ident"()
-    unless $P10, rx548_fail
-    rx548_cur."!mark_push"(0, -1, 0, $P10)
+    rx529_cur."!cursor_pos"(rx529_pos)
+    $P10 = rx529_cur."mod_ident"()
+    unless $P10, rx529_fail
+    rx529_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("mod_ident")
-    rx548_pos = $P10."pos"()
+    rx529_pos = $P10."pos"()
   # rxanchor rwb
-    le rx548_pos, 0, rx548_fail
-    sub $I10, rx548_pos, rx548_off
-    is_cclass $I11, 8192, rx548_tgt, $I10
-    if $I11, rx548_fail
+    le rx529_pos, 0, rx529_fail
+    sub $I10, rx529_pos, rx529_off
+    is_cclass $I11, 8192, rx529_tgt, $I10
+    if $I11, rx529_fail
     dec $I10
-    is_cclass $I11, 8192, rx548_tgt, $I10
-    unless $I11, rx548_fail
-    goto alt553_end
-  alt553_1:
+    is_cclass $I11, 8192, rx529_tgt, $I10
+    unless $I11, rx529_fail
+    goto alt534_end
+  alt534_1:
 .annotate 'line', 179
   # rx literal  ":"
-    add $I11, rx548_pos, 1
-    gt $I11, rx548_eos, rx548_fail
-    sub $I11, rx548_pos, rx548_off
-    substr $S10, rx548_tgt, $I11, 1
-    ne $S10, ":", rx548_fail
-    add rx548_pos, 1
+    add $I11, rx529_pos, 1
+    gt $I11, rx529_eos, rx529_fail
+    sub $I11, rx529_pos, rx529_off
+    substr $S10, rx529_tgt, $I11, 1
+    ne $S10, ":", rx529_fail
+    add rx529_pos, 1
   # rx subrule "mod_ident" subtype=capture negate=
-    rx548_cur."!cursor_pos"(rx548_pos)
-    $P10 = rx548_cur."mod_ident"()
-    unless $P10, rx548_fail
-    rx548_cur."!mark_push"(0, -1, 0, $P10)
+    rx529_cur."!cursor_pos"(rx529_pos)
+    $P10 = rx529_cur."mod_ident"()
+    unless $P10, rx529_fail
+    rx529_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("mod_ident")
-    rx548_pos = $P10."pos"()
-  # rx rxquantr561 ** 0..1
-    set_addr $I563, rxquantr561_done
-    rx548_cur."!mark_push"(0, rx548_pos, $I563)
-  rxquantr561_loop:
+    rx529_pos = $P10."pos"()
+  # rx rxquantr542 ** 0..1
+    set_addr $I10, rxquantr542_done
+    rx529_cur."!mark_push"(0, rx529_pos, $I10)
+  rxquantr542_loop:
   # rx literal  "("
-    add $I11, rx548_pos, 1
-    gt $I11, rx548_eos, rx548_fail
-    sub $I11, rx548_pos, rx548_off
-    substr $S10, rx548_tgt, $I11, 1
-    ne $S10, "(", rx548_fail
-    add rx548_pos, 1
+    add $I11, rx529_pos, 1
+    gt $I11, rx529_eos, rx529_fail
+    sub $I11, rx529_pos, rx529_off
+    substr $S10, rx529_tgt, $I11, 1
+    ne $S10, "(", rx529_fail
+    add rx529_pos, 1
   # rx subcapture "n"
-    set_addr $I10, rxcap_562_fail
-    rx548_cur."!mark_push"(0, rx548_pos, $I10)
+    set_addr $I10, rxcap_543_fail
+    rx529_cur."!mark_push"(0, rx529_pos, $I10)
   # rx charclass_q d r 1..-1
-    sub $I10, rx548_pos, rx548_off
-    find_not_cclass $I11, 8, rx548_tgt, $I10, rx548_eos
+    sub $I10, rx529_pos, rx529_off
+    find_not_cclass $I11, 8, rx529_tgt, $I10, rx529_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx548_fail
-    add rx548_pos, rx548_off, $I11
-    set_addr $I10, rxcap_562_fail
-    ($I12, $I11) = rx548_cur."!mark_peek"($I10)
-    rx548_cur."!cursor_pos"($I11)
-    ($P10) = rx548_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx548_pos, "")
-    rx548_cur."!mark_push"(0, -1, 0, $P10)
+    lt $I11, $I12, rx529_fail
+    add rx529_pos, rx529_off, $I11
+    set_addr $I10, rxcap_543_fail
+    ($I12, $I11) = rx529_cur."!mark_peek"($I10)
+    rx529_cur."!cursor_pos"($I11)
+    ($P10) = rx529_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx529_pos, "")
+    rx529_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("n")
-    goto rxcap_562_done
-  rxcap_562_fail:
-    goto rx548_fail
-  rxcap_562_done:
+    goto rxcap_543_done
+  rxcap_543_fail:
+    goto rx529_fail
+  rxcap_543_done:
   # rx literal  ")"
-    add $I11, rx548_pos, 1
-    gt $I11, rx548_eos, rx548_fail
-    sub $I11, rx548_pos, rx548_off
-    substr $S10, rx548_tgt, $I11, 1
-    ne $S10, ")", rx548_fail
-    add rx548_pos, 1
-    (rx548_rep) = rx548_cur."!mark_commit"($I563)
-  rxquantr561_done:
-  alt553_end:
+    add $I11, rx529_pos, 1
+    gt $I11, rx529_eos, rx529_fail
+    sub $I11, rx529_pos, rx529_off
+    substr $S10, rx529_tgt, $I11, 1
+    ne $S10, ")", rx529_fail
+    add rx529_pos, 1
+    set_addr $I10, rxquantr542_done
+    (rx529_rep) = rx529_cur."!mark_commit"($I10)
+  rxquantr542_done:
+  alt534_end:
 .annotate 'line', 176
   # rx pass
-    rx548_cur."!cursor_pass"(rx548_pos, "mod_internal")
-    rx548_cur."!cursor_debug"("PASS  ", "mod_internal", " at pos=", rx548_pos)
-    .return (rx548_cur)
-  rx548_fail:
+    rx529_cur."!cursor_pass"(rx529_pos, "mod_internal")
+    rx529_cur."!cursor_debug"("PASS  ", "mod_internal", " at pos=", rx529_pos)
+    .return (rx529_cur)
+  rx529_restart:
 .annotate 'line', 3
-    (rx548_rep, rx548_pos, $I10, $P10) = rx548_cur."!mark_fail"(0)
-    lt rx548_pos, -1, rx548_done
-    eq rx548_pos, -1, rx548_fail
+    rx529_cur."!cursor_debug"("NEXT ", "mod_internal")
+  rx529_fail:
+    (rx529_rep, rx529_pos, $I10, $P10) = rx529_cur."!mark_fail"(0)
+    lt rx529_pos, -1, rx529_done
+    eq rx529_pos, -1, rx529_fail
     jump $I10
-  rx548_done:
-    rx548_cur."!cursor_fail"()
-    rx548_cur."!cursor_debug"("FAIL  ", "mod_internal")
-    .return (rx548_cur)
+  rx529_done:
+    rx529_cur."!cursor_fail"()
+    rx529_cur."!cursor_debug"("FAIL  ", "mod_internal")
+    .return (rx529_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__mod_internal"  :subid("150_1278500530.77787") :method
+.sub "!PREFIX__mod_internal"  :subid("150_1279529218.55263") :method
 .annotate 'line', 3
-    $P550 = self."!PREFIX__!subrule"("mod_ident", ":")
-    new $P551, "ResizablePMCArray"
-    push $P551, $P550
-    push $P551, ":"
-    .return ($P551)
+    $P531 = self."!PREFIX__!subrule"("mod_ident", ":")
+    new $P532, "ResizablePMCArray"
+    push $P532, $P531
+    push $P532, ":"
+    .return ($P532)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block555"  :anon :subid("151_1278500530.77787") :method :outer("149_1278500530.77787")
+.sub "_block536"  :anon :subid("151_1279529218.55263") :method :outer("149_1279529218.55263")
 .annotate 'line', 178
-    .local string rx557_tgt
-    .local int rx557_pos
-    .local int rx557_off
-    .local int rx557_eos
-    .local int rx557_rep
-    .local pmc rx557_cur
-    (rx557_cur, rx557_pos, rx557_tgt) = self."!cursor_start"()
-    rx557_cur."!cursor_debug"("START ", "")
-    .lex unicode:"$\x{a2}", rx557_cur
-    .local pmc match
-    .lex "$/", match
-    length rx557_eos, rx557_tgt
-    gt rx557_pos, rx557_eos, rx557_done
-    set rx557_off, 0
-    lt rx557_pos, 2, rx557_start
-    sub rx557_off, rx557_pos, 1
-    substr rx557_tgt, rx557_tgt, rx557_off
-  rx557_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan558_done
-    goto rxscan558_scan
-  rxscan558_loop:
-    ($P10) = rx557_cur."from"()
-    inc $P10
-    set rx557_pos, $P10
-    ge rx557_pos, rx557_eos, rxscan558_done
-  rxscan558_scan:
-    set_addr $I10, rxscan558_loop
-    rx557_cur."!mark_push"(0, rx557_pos, $I10)
-  rxscan558_done:
-  alt559_0:
-    set_addr $I10, alt559_1
-    rx557_cur."!mark_push"(0, rx557_pos, $I10)
+    .local string rx538_tgt
+    .local int rx538_pos
+    .local int rx538_off
+    .local int rx538_eos
+    .local int rx538_rep
+    .local pmc rx538_cur
+    (rx538_cur, rx538_pos, rx538_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx538_cur
+    .local pmc match
+    .lex "$/", match
+    length rx538_eos, rx538_tgt
+    gt rx538_pos, rx538_eos, rx538_done
+    set rx538_off, 0
+    lt rx538_pos, 2, rx538_start
+    sub rx538_off, rx538_pos, 1
+    substr rx538_tgt, rx538_tgt, rx538_off
+  rx538_start:
+    eq $I10, 1, rx538_restart
+    rx538_cur."!cursor_debug"("START ", "")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan539_done
+    goto rxscan539_scan
+  rxscan539_loop:
+    ($P10) = rx538_cur."from"()
+    inc $P10
+    set rx538_pos, $P10
+    ge rx538_pos, rx538_eos, rxscan539_done
+  rxscan539_scan:
+    set_addr $I10, rxscan539_loop
+    rx538_cur."!mark_push"(0, rx538_pos, $I10)
+  rxscan539_done:
+  alt540_0:
+    set_addr $I10, alt540_1
+    rx538_cur."!mark_push"(0, rx538_pos, $I10)
   # rx literal  "!"
-    add $I11, rx557_pos, 1
-    gt $I11, rx557_eos, rx557_fail
-    sub $I11, rx557_pos, rx557_off
-    substr $S10, rx557_tgt, $I11, 1
-    ne $S10, "!", rx557_fail
-    add rx557_pos, 1
-    goto alt559_end
-  alt559_1:
+    add $I11, rx538_pos, 1
+    gt $I11, rx538_eos, rx538_fail
+    sub $I11, rx538_pos, rx538_off
+    substr $S10, rx538_tgt, $I11, 1
+    ne $S10, "!", rx538_fail
+    add rx538_pos, 1
+    goto alt540_end
+  alt540_1:
   # rx charclass_q d r 1..-1
-    sub $I10, rx557_pos, rx557_off
-    find_not_cclass $I11, 8, rx557_tgt, $I10, rx557_eos
+    sub $I10, rx538_pos, rx538_off
+    find_not_cclass $I11, 8, rx538_tgt, $I10, rx538_eos
     add $I12, $I10, 1
-    lt $I11, $I12, rx557_fail
-    add rx557_pos, rx557_off, $I11
-  alt559_end:
+    lt $I11, $I12, rx538_fail
+    add rx538_pos, rx538_off, $I11
+  alt540_end:
   # rx pass
-    rx557_cur."!cursor_pass"(rx557_pos, "")
-    rx557_cur."!cursor_debug"("PASS  ", "", " at pos=", rx557_pos)
-    .return (rx557_cur)
-  rx557_fail:
-    (rx557_rep, rx557_pos, $I10, $P10) = rx557_cur."!mark_fail"(0)
-    lt rx557_pos, -1, rx557_done
-    eq rx557_pos, -1, rx557_fail
+    rx538_cur."!cursor_pass"(rx538_pos, "")
+    rx538_cur."!cursor_debug"("PASS  ", "", " at pos=", rx538_pos)
+    .return (rx538_cur)
+  rx538_restart:
+    rx538_cur."!cursor_debug"("NEXT ", "")
+  rx538_fail:
+    (rx538_rep, rx538_pos, $I10, $P10) = rx538_cur."!mark_fail"(0)
+    lt rx538_pos, -1, rx538_done
+    eq rx538_pos, -1, rx538_fail
     jump $I10
-  rx557_done:
-    rx557_cur."!cursor_fail"()
-    rx557_cur."!cursor_debug"("FAIL  ", "")
-    .return (rx557_cur)
+  rx538_done:
+    rx538_cur."!cursor_fail"()
+    rx538_cur."!cursor_debug"("FAIL  ", "")
+    .return (rx538_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "mod_ident"  :subid("152_1278500530.77787") :method
+.sub "mod_ident"  :subid("152_1279529218.55263") :method
 .annotate 'line', 183
-    $P565 = self."!protoregex"("mod_ident")
-    .return ($P565)
+    $P545 = self."!protoregex"("mod_ident")
+    .return ($P545)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__mod_ident"  :subid("153_1278500530.77787") :method
+.sub "!PREFIX__mod_ident"  :subid("153_1279529218.55263") :method
 .annotate 'line', 183
-    $P567 = self."!PREFIX__!protoregex"("mod_ident")
-    .return ($P567)
+    $P547 = self."!PREFIX__!protoregex"("mod_ident")
+    .return ($P547)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "mod_ident:sym<ignorecase>"  :subid("154_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "mod_ident:sym<ignorecase>"  :subid("154_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx569_tgt
-    .local int rx569_pos
-    .local int rx569_off
-    .local int rx569_eos
-    .local int rx569_rep
-    .local pmc rx569_cur
-    (rx569_cur, rx569_pos, rx569_tgt) = self."!cursor_start"()
-    rx569_cur."!cursor_debug"("START ", "mod_ident:sym<ignorecase>")
-    .lex unicode:"$\x{a2}", rx569_cur
-    .local pmc match
-    .lex "$/", match
-    length rx569_eos, rx569_tgt
-    gt rx569_pos, rx569_eos, rx569_done
-    set rx569_off, 0
-    lt rx569_pos, 2, rx569_start
-    sub rx569_off, rx569_pos, 1
-    substr rx569_tgt, rx569_tgt, rx569_off
-  rx569_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan572_done
-    goto rxscan572_scan
-  rxscan572_loop:
-    ($P10) = rx569_cur."from"()
-    inc $P10
-    set rx569_pos, $P10
-    ge rx569_pos, rx569_eos, rxscan572_done
-  rxscan572_scan:
-    set_addr $I10, rxscan572_loop
-    rx569_cur."!mark_push"(0, rx569_pos, $I10)
-  rxscan572_done:
+    .local string rx549_tgt
+    .local int rx549_pos
+    .local int rx549_off
+    .local int rx549_eos
+    .local int rx549_rep
+    .local pmc rx549_cur
+    (rx549_cur, rx549_pos, rx549_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx549_cur
+    .local pmc match
+    .lex "$/", match
+    length rx549_eos, rx549_tgt
+    gt rx549_pos, rx549_eos, rx549_done
+    set rx549_off, 0
+    lt rx549_pos, 2, rx549_start
+    sub rx549_off, rx549_pos, 1
+    substr rx549_tgt, rx549_tgt, rx549_off
+  rx549_start:
+    eq $I10, 1, rx549_restart
+    rx549_cur."!cursor_debug"("START ", "mod_ident:sym<ignorecase>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan552_done
+    goto rxscan552_scan
+  rxscan552_loop:
+    ($P10) = rx549_cur."from"()
+    inc $P10
+    set rx549_pos, $P10
+    ge rx549_pos, rx549_eos, rxscan552_done
+  rxscan552_scan:
+    set_addr $I10, rxscan552_loop
+    rx549_cur."!mark_push"(0, rx549_pos, $I10)
+  rxscan552_done:
 .annotate 'line', 184
   # rx subcapture "sym"
-    set_addr $I10, rxcap_573_fail
-    rx569_cur."!mark_push"(0, rx569_pos, $I10)
+    set_addr $I10, rxcap_553_fail
+    rx549_cur."!mark_push"(0, rx549_pos, $I10)
   # rx literal  "i"
-    add $I11, rx569_pos, 1
-    gt $I11, rx569_eos, rx569_fail
-    sub $I11, rx569_pos, rx569_off
-    substr $S10, rx569_tgt, $I11, 1
-    ne $S10, "i", rx569_fail
-    add rx569_pos, 1
-    set_addr $I10, rxcap_573_fail
-    ($I12, $I11) = rx569_cur."!mark_peek"($I10)
-    rx569_cur."!cursor_pos"($I11)
-    ($P10) = rx569_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx569_pos, "")
-    rx569_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx549_pos, 1
+    gt $I11, rx549_eos, rx549_fail
+    sub $I11, rx549_pos, rx549_off
+    substr $S10, rx549_tgt, $I11, 1
+    ne $S10, "i", rx549_fail
+    add rx549_pos, 1
+    set_addr $I10, rxcap_553_fail
+    ($I12, $I11) = rx549_cur."!mark_peek"($I10)
+    rx549_cur."!cursor_pos"($I11)
+    ($P10) = rx549_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx549_pos, "")
+    rx549_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_573_done
-  rxcap_573_fail:
-    goto rx569_fail
-  rxcap_573_done:
-  # rx rxquantr574 ** 0..1
-    set_addr $I575, rxquantr574_done
-    rx569_cur."!mark_push"(0, rx569_pos, $I575)
-  rxquantr574_loop:
+    goto rxcap_553_done
+  rxcap_553_fail:
+    goto rx549_fail
+  rxcap_553_done:
+  # rx rxquantr554 ** 0..1
+    set_addr $I10, rxquantr554_done
+    rx549_cur."!mark_push"(0, rx549_pos, $I10)
+  rxquantr554_loop:
   # rx literal  "gnorecase"
-    add $I11, rx569_pos, 9
-    gt $I11, rx569_eos, rx569_fail
-    sub $I11, rx569_pos, rx569_off
-    substr $S10, rx569_tgt, $I11, 9
-    ne $S10, "gnorecase", rx569_fail
-    add rx569_pos, 9
-    (rx569_rep) = rx569_cur."!mark_commit"($I575)
-  rxquantr574_done:
+    add $I11, rx549_pos, 9
+    gt $I11, rx549_eos, rx549_fail
+    sub $I11, rx549_pos, rx549_off
+    substr $S10, rx549_tgt, $I11, 9
+    ne $S10, "gnorecase", rx549_fail
+    add rx549_pos, 9
+    set_addr $I10, rxquantr554_done
+    (rx549_rep) = rx549_cur."!mark_commit"($I10)
+  rxquantr554_done:
   # rx pass
-    rx569_cur."!cursor_pass"(rx569_pos, "mod_ident:sym<ignorecase>")
-    rx569_cur."!cursor_debug"("PASS  ", "mod_ident:sym<ignorecase>", " at pos=", rx569_pos)
-    .return (rx569_cur)
-  rx569_fail:
+    rx549_cur."!cursor_pass"(rx549_pos, "mod_ident:sym<ignorecase>")
+    rx549_cur."!cursor_debug"("PASS  ", "mod_ident:sym<ignorecase>", " at pos=", rx549_pos)
+    .return (rx549_cur)
+  rx549_restart:
 .annotate 'line', 3
-    (rx569_rep, rx569_pos, $I10, $P10) = rx569_cur."!mark_fail"(0)
-    lt rx569_pos, -1, rx569_done
-    eq rx569_pos, -1, rx569_fail
+    rx549_cur."!cursor_debug"("NEXT ", "mod_ident:sym<ignorecase>")
+  rx549_fail:
+    (rx549_rep, rx549_pos, $I10, $P10) = rx549_cur."!mark_fail"(0)
+    lt rx549_pos, -1, rx549_done
+    eq rx549_pos, -1, rx549_fail
     jump $I10
-  rx569_done:
-    rx569_cur."!cursor_fail"()
-    rx569_cur."!cursor_debug"("FAIL  ", "mod_ident:sym<ignorecase>")
-    .return (rx569_cur)
+  rx549_done:
+    rx549_cur."!cursor_fail"()
+    rx549_cur."!cursor_debug"("FAIL  ", "mod_ident:sym<ignorecase>")
+    .return (rx549_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__mod_ident:sym<ignorecase>"  :subid("155_1278500530.77787") :method
+.sub "!PREFIX__mod_ident:sym<ignorecase>"  :subid("155_1279529218.55263") :method
 .annotate 'line', 3
-    new $P571, "ResizablePMCArray"
-    push $P571, "i"
-    .return ($P571)
+    new $P551, "ResizablePMCArray"
+    push $P551, "i"
+    .return ($P551)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "mod_ident:sym<ratchet>"  :subid("156_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "mod_ident:sym<ratchet>"  :subid("156_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx577_tgt
-    .local int rx577_pos
-    .local int rx577_off
-    .local int rx577_eos
-    .local int rx577_rep
-    .local pmc rx577_cur
-    (rx577_cur, rx577_pos, rx577_tgt) = self."!cursor_start"()
-    rx577_cur."!cursor_debug"("START ", "mod_ident:sym<ratchet>")
-    .lex unicode:"$\x{a2}", rx577_cur
-    .local pmc match
-    .lex "$/", match
-    length rx577_eos, rx577_tgt
-    gt rx577_pos, rx577_eos, rx577_done
-    set rx577_off, 0
-    lt rx577_pos, 2, rx577_start
-    sub rx577_off, rx577_pos, 1
-    substr rx577_tgt, rx577_tgt, rx577_off
-  rx577_start:
-    $I10 = self.'from'()
-    ne $I10, -1, rxscan580_done
-    goto rxscan580_scan
-  rxscan580_loop:
-    ($P10) = rx577_cur."from"()
-    inc $P10
-    set rx577_pos, $P10
-    ge rx577_pos, rx577_eos, rxscan580_done
-  rxscan580_scan:
-    set_addr $I10, rxscan580_loop
-    rx577_cur."!mark_push"(0, rx577_pos, $I10)
-  rxscan580_done:
+    .local string rx556_tgt
+    .local int rx556_pos
+    .local int rx556_off
+    .local int rx556_eos
+    .local int rx556_rep
+    .local pmc rx556_cur
+    (rx556_cur, rx556_pos, rx556_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx556_cur
+    .local pmc match
+    .lex "$/", match
+    length rx556_eos, rx556_tgt
+    gt rx556_pos, rx556_eos, rx556_done
+    set rx556_off, 0
+    lt rx556_pos, 2, rx556_start
+    sub rx556_off, rx556_pos, 1
+    substr rx556_tgt, rx556_tgt, rx556_off
+  rx556_start:
+    eq $I10, 1, rx556_restart
+    rx556_cur."!cursor_debug"("START ", "mod_ident:sym<ratchet>")
+    $I10 = self.'from'()
+    ne $I10, -1, rxscan559_done
+    goto rxscan559_scan
+  rxscan559_loop:
+    ($P10) = rx556_cur."from"()
+    inc $P10
+    set rx556_pos, $P10
+    ge rx556_pos, rx556_eos, rxscan559_done
+  rxscan559_scan:
+    set_addr $I10, rxscan559_loop
+    rx556_cur."!mark_push"(0, rx556_pos, $I10)
+  rxscan559_done:
 .annotate 'line', 185
   # rx subcapture "sym"
-    set_addr $I10, rxcap_581_fail
-    rx577_cur."!mark_push"(0, rx577_pos, $I10)
+    set_addr $I10, rxcap_560_fail
+    rx556_cur."!mark_push"(0, rx556_pos, $I10)
   # rx literal  "r"
-    add $I11, rx577_pos, 1
-    gt $I11, rx577_eos, rx577_fail
-    sub $I11, rx577_pos, rx577_off
-    substr $S10, rx577_tgt, $I11, 1
-    ne $S10, "r", rx577_fail
-    add rx577_pos, 1
-    set_addr $I10, rxcap_581_fail
-    ($I12, $I11) = rx577_cur."!mark_peek"($I10)
-    rx577_cur."!cursor_pos"($I11)
-    ($P10) = rx577_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx577_pos, "")
-    rx577_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx556_pos, 1
+    gt $I11, rx556_eos, rx556_fail
+    sub $I11, rx556_pos, rx556_off
+    substr $S10, rx556_tgt, $I11, 1
+    ne $S10, "r", rx556_fail
+    add rx556_pos, 1
+    set_addr $I10, rxcap_560_fail
+    ($I12, $I11) = rx556_cur."!mark_peek"($I10)
+    rx556_cur."!cursor_pos"($I11)
+    ($P10) = rx556_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx556_pos, "")
+    rx556_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_581_done
-  rxcap_581_fail:
-    goto rx577_fail
-  rxcap_581_done:
-  # rx rxquantr582 ** 0..1
-    set_addr $I583, rxquantr582_done
-    rx577_cur."!mark_push"(0, rx577_pos, $I583)
-  rxquantr582_loop:
+    goto rxcap_560_done
+  rxcap_560_fail:
+    goto rx556_fail
+  rxcap_560_done:
+  # rx rxquantr561 ** 0..1
+    set_addr $I10, rxquantr561_done
+    rx556_cur."!mark_push"(0, rx556_pos, $I10)
+  rxquantr561_loop:
   # rx literal  "atchet"
-    add $I11, rx577_pos, 6
-    gt $I11, rx577_eos, rx577_fail
-    sub $I11, rx577_pos, rx577_off
-    substr $S10, rx577_tgt, $I11, 6
-    ne $S10, "atchet", rx577_fail
-    add rx577_pos, 6
-    (rx577_rep) = rx577_cur."!mark_commit"($I583)
-  rxquantr582_done:
+    add $I11, rx556_pos, 6
+    gt $I11, rx556_eos, rx556_fail
+    sub $I11, rx556_pos, rx556_off
+    substr $S10, rx556_tgt, $I11, 6
+    ne $S10, "atchet", rx556_fail
+    add rx556_pos, 6
+    set_addr $I10, rxquantr561_done
+    (rx556_rep) = rx556_cur."!mark_commit"($I10)
+  rxquantr561_done:
   # rx pass
-    rx577_cur."!cursor_pass"(rx577_pos, "mod_ident:sym<ratchet>")
-    rx577_cur."!cursor_debug"("PASS  ", "mod_ident:sym<ratchet>", " at pos=", rx577_pos)
-    .return (rx577_cur)
-  rx577_fail:
+    rx556_cur."!cursor_pass"(rx556_pos, "mod_ident:sym<ratchet>")
+    rx556_cur."!cursor_debug"("PASS  ", "mod_ident:sym<ratchet>", " at pos=", rx556_pos)
+    .return (rx556_cur)
+  rx556_restart:
 .annotate 'line', 3
-    (rx577_rep, rx577_pos, $I10, $P10) = rx577_cur."!mark_fail"(0)
-    lt rx577_pos, -1, rx577_done
-    eq rx577_pos, -1, rx577_fail
+    rx556_cur."!cursor_debug"("NEXT ", "mod_ident:sym<ratchet>")
+  rx556_fail:
+    (rx556_rep, rx556_pos, $I10, $P10) = rx556_cur."!mark_fail"(0)
+    lt rx556_pos, -1, rx556_done
+    eq rx556_pos, -1, rx556_fail
     jump $I10
-  rx577_done:
-    rx577_cur."!cursor_fail"()
-    rx577_cur."!cursor_debug"("FAIL  ", "mod_ident:sym<ratchet>")
-    .return (rx577_cur)
+  rx556_done:
+    rx556_cur."!cursor_fail"()
+    rx556_cur."!cursor_debug"("FAIL  ", "mod_ident:sym<ratchet>")
+    .return (rx556_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__mod_ident:sym<ratchet>"  :subid("157_1278500530.77787") :method
+.sub "!PREFIX__mod_ident:sym<ratchet>"  :subid("157_1279529218.55263") :method
 .annotate 'line', 3
-    new $P579, "ResizablePMCArray"
-    push $P579, "r"
-    .return ($P579)
+    new $P558, "ResizablePMCArray"
+    push $P558, "r"
+    .return ($P558)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "mod_ident:sym<sigspace>"  :subid("158_1278500530.77787") :method :outer("11_1278500530.77787")
+.sub "mod_ident:sym<sigspace>"  :subid("158_1279529218.55263") :method :outer("11_1279529218.55263")
 .annotate 'line', 3
-    .local string rx585_tgt
-    .local int rx585_pos
-    .local int rx585_off
-    .local int rx585_eos
-    .local int rx585_rep
-    .local pmc rx585_cur
-    (rx585_cur, rx585_pos, rx585_tgt) = self."!cursor_start"()
-    rx585_cur."!cursor_debug"("START ", "mod_ident:sym<sigspace>")
-    .lex unicode:"$\x{a2}", rx585_cur
+    .local string rx563_tgt
+    .local int rx563_pos
+    .local int rx563_off
+    .local int rx563_eos
+    .local int rx563_rep
+    .local pmc rx563_cur
+    (rx563_cur, rx563_pos, rx563_tgt, $I10) = self."!cursor_start"()
+    .lex unicode:"$\x{a2}", rx563_cur
     .local pmc match
     .lex "$/", match
-    length rx585_eos, rx585_tgt
-    gt rx585_pos, rx585_eos, rx585_done
-    set rx585_off, 0
-    lt rx585_pos, 2, rx585_start
-    sub rx585_off, rx585_pos, 1
-    substr rx585_tgt, rx585_tgt, rx585_off
-  rx585_start:
+    length rx563_eos, rx563_tgt
+    gt rx563_pos, rx563_eos, rx563_done
+    set rx563_off, 0
+    lt rx563_pos, 2, rx563_start
+    sub rx563_off, rx563_pos, 1
+    substr rx563_tgt, rx563_tgt, rx563_off
+  rx563_start:
+    eq $I10, 1, rx563_restart
+    rx563_cur."!cursor_debug"("START ", "mod_ident:sym<sigspace>")
     $I10 = self.'from'()
-    ne $I10, -1, rxscan588_done
-    goto rxscan588_scan
-  rxscan588_loop:
-    ($P10) = rx585_cur."from"()
+    ne $I10, -1, rxscan566_done
+    goto rxscan566_scan
+  rxscan566_loop:
+    ($P10) = rx563_cur."from"()
     inc $P10
-    set rx585_pos, $P10
-    ge rx585_pos, rx585_eos, rxscan588_done
-  rxscan588_scan:
-    set_addr $I10, rxscan588_loop
-    rx585_cur."!mark_push"(0, rx585_pos, $I10)
-  rxscan588_done:
+    set rx563_pos, $P10
+    ge rx563_pos, rx563_eos, rxscan566_done
+  rxscan566_scan:
+    set_addr $I10, rxscan566_loop
+    rx563_cur."!mark_push"(0, rx563_pos, $I10)
+  rxscan566_done:
 .annotate 'line', 186
   # rx subcapture "sym"
-    set_addr $I10, rxcap_589_fail
-    rx585_cur."!mark_push"(0, rx585_pos, $I10)
+    set_addr $I10, rxcap_567_fail
+    rx563_cur."!mark_push"(0, rx563_pos, $I10)
   # rx literal  "s"
-    add $I11, rx585_pos, 1
-    gt $I11, rx585_eos, rx585_fail
-    sub $I11, rx585_pos, rx585_off
-    substr $S10, rx585_tgt, $I11, 1
-    ne $S10, "s", rx585_fail
-    add rx585_pos, 1
-    set_addr $I10, rxcap_589_fail
-    ($I12, $I11) = rx585_cur."!mark_peek"($I10)
-    rx585_cur."!cursor_pos"($I11)
-    ($P10) = rx585_cur."!cursor_start"()
-    $P10."!cursor_pass"(rx585_pos, "")
-    rx585_cur."!mark_push"(0, -1, 0, $P10)
+    add $I11, rx563_pos, 1
+    gt $I11, rx563_eos, rx563_fail
+    sub $I11, rx563_pos, rx563_off
+    substr $S10, rx563_tgt, $I11, 1
+    ne $S10, "s", rx563_fail
+    add rx563_pos, 1
+    set_addr $I10, rxcap_567_fail
+    ($I12, $I11) = rx563_cur."!mark_peek"($I10)
+    rx563_cur."!cursor_pos"($I11)
+    ($P10) = rx563_cur."!cursor_start"()
+    $P10."!cursor_pass"(rx563_pos, "")
+    rx563_cur."!mark_push"(0, -1, 0, $P10)
     $P10."!cursor_names"("sym")
-    goto rxcap_589_done
-  rxcap_589_fail:
-    goto rx585_fail
-  rxcap_589_done:
-  # rx rxquantr590 ** 0..1
-    set_addr $I591, rxquantr590_done
-    rx585_cur."!mark_push"(0, rx585_pos, $I591)
-  rxquantr590_loop:
+    goto rxcap_567_done
+  rxcap_567_fail:
+    goto rx563_fail
+  rxcap_567_done:
+  # rx rxquantr568 ** 0..1
+    set_addr $I10, rxquantr568_done
+    rx563_cur."!mark_push"(0, rx563_pos, $I10)
+  rxquantr568_loop:
   # rx literal  "igspace"
-    add $I11, rx585_pos, 7
-    gt $I11, rx585_eos, rx585_fail
-    sub $I11, rx585_pos, rx585_off
-    substr $S10, rx585_tgt, $I11, 7
-    ne $S10, "igspace", rx585_fail
-    add rx585_pos, 7
-    (rx585_rep) = rx585_cur."!mark_commit"($I591)
-  rxquantr590_done:
+    add $I11, rx563_pos, 7
+    gt $I11, rx563_eos, rx563_fail
+    sub $I11, rx563_pos, rx563_off
+    substr $S10, rx563_tgt, $I11, 7
+    ne $S10, "igspace", rx563_fail
+    add rx563_pos, 7
+    set_addr $I10, rxquantr568_done
+    (rx563_rep) = rx563_cur."!mark_commit"($I10)
+  rxquantr568_done:
   # rx pass
-    rx585_cur."!cursor_pass"(rx585_pos, "mod_ident:sym<sigspace>")
-    rx585_cur."!cursor_debug"("PASS  ", "mod_ident:sym<sigspace>", " at pos=", rx585_pos)
-    .return (rx585_cur)
-  rx585_fail:
+    rx563_cur."!cursor_pass"(rx563_pos, "mod_ident:sym<sigspace>")
+    rx563_cur."!cursor_debug"("PASS  ", "mod_ident:sym<sigspace>", " at pos=", rx563_pos)
+    .return (rx563_cur)
+  rx563_restart:
 .annotate 'line', 3
-    (rx585_rep, rx585_pos, $I10, $P10) = rx585_cur."!mark_fail"(0)
-    lt rx585_pos, -1, rx585_done
-    eq rx585_pos, -1, rx585_fail
+    rx563_cur."!cursor_debug"("NEXT ", "mod_ident:sym<sigspace>")
+  rx563_fail:
+    (rx563_rep, rx563_pos, $I10, $P10) = rx563_cur."!mark_fail"(0)
+    lt rx563_pos, -1, rx563_done
+    eq rx563_pos, -1, rx563_fail
     jump $I10
-  rx585_done:
-    rx585_cur."!cursor_fail"()
-    rx585_cur."!cursor_debug"("FAIL  ", "mod_ident:sym<sigspace>")
-    .return (rx585_cur)
+  rx563_done:
+    rx563_cur."!cursor_fail"()
+    rx563_cur."!cursor_debug"("FAIL  ", "mod_ident:sym<sigspace>")
+    .return (rx563_cur)
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "!PREFIX__mod_ident:sym<sigspace>"  :subid("159_1278500530.77787") :method
+.sub "!PREFIX__mod_ident:sym<sigspace>"  :subid("159_1279529218.55263") :method
 .annotate 'line', 3
-    new $P587, "ResizablePMCArray"
-    push $P587, "s"
-    .return ($P587)
+    new $P565, "ResizablePMCArray"
+    push $P565, "s"
+    .return ($P565)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Grammar"]
-.sub "_block592" :load :anon :subid("160_1278500530.77787")
+.sub "_block569" :load :anon :subid("160_1279529218.55263")
 .annotate 'line', 3
-    .const 'Sub' $P594 = "11_1278500530.77787" 
-    $P595 = $P594()
-    .return ($P595)
+    .const 'Sub' $P571 = "11_1279529218.55263" 
+    $P572 = $P571()
+    .return ($P572)
 .end
 
 
 .namespace []
-.sub "_block597" :load :anon :subid("161_1278500530.77787")
+.sub "_block574" :load :anon :subid("161_1279529218.55263")
 .annotate 'line', 1
-    .const 'Sub' $P599 = "10_1278500530.77787" 
-    $P600 = $P599()
-    .return ($P600)
+    .const 'Sub' $P576 = "10_1279529218.55263" 
+    $P577 = $P576()
+    .return ($P577)
 .end
 
 ### .include 'gen/p6regex-actions.pir'
 
 .namespace []
-.sub "_block11"  :anon :subid("10_1278500533.96053")
+.sub "_block11"  :anon :subid("10_1279529222.65073")
 .annotate 'line', 0
     get_hll_global $P14, ["Regex";"P6Regex";"Actions"], "_block13" 
     capture_lex $P14
@@ -7373,153 +7690,155 @@
 .annotate 'line', 4
     get_hll_global $P14, ["Regex";"P6Regex";"Actions"], "_block13" 
     capture_lex $P14
-    $P1601 = $P14()
+    $P1623 = $P14()
 .annotate 'line', 1
-    .return ($P1601)
-    .const 'Sub' $P1603 = "91_1278500533.96053" 
-    .return ($P1603)
+    .return ($P1623)
+    .const 'Sub' $P1625 = "92_1279529222.65073" 
+    .return ($P1625)
 .end
 
 
 .namespace []
-.sub "" :load :init :subid("post92") :outer("10_1278500533.96053")
+.sub "" :load :init :subid("post93") :outer("10_1279529222.65073")
 .annotate 'line', 0
-    .const 'Sub' $P12 = "10_1278500533.96053" 
+    .const 'Sub' $P12 = "10_1279529222.65073" 
     .local pmc block
     set block, $P12
-    $P1606 = get_root_global ["parrot"], "P6metaclass"
-    $P1606."new_class"("Regex::P6Regex::Actions", "HLL::Actions" :named("parent"))
+    $P1628 = get_root_global ["parrot"], "P6metaclass"
+    $P1628."new_class"("Regex::P6Regex::Actions", "HLL::Actions" :named("parent"))
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block13"  :subid("11_1278500533.96053") :outer("10_1278500533.96053")
+.sub "_block13"  :subid("11_1279529222.65073") :outer("10_1279529222.65073")
 .annotate 'line', 4
-    .const 'Sub' $P1575 = "89_1278500533.96053" 
-    capture_lex $P1575
-    .const 'Sub' $P1543 = "88_1278500533.96053" 
-    capture_lex $P1543
-    .const 'Sub' $P1474 = "84_1278500533.96053" 
-    capture_lex $P1474
-    .const 'Sub' $P1406 = "82_1278500533.96053" 
-    capture_lex $P1406
-    .const 'Sub' $P1332 = "79_1278500533.96053" 
-    capture_lex $P1332
-    .const 'Sub' $P1318 = "78_1278500533.96053" 
-    capture_lex $P1318
-    .const 'Sub' $P1294 = "77_1278500533.96053" 
-    capture_lex $P1294
-    .const 'Sub' $P1276 = "76_1278500533.96053" 
-    capture_lex $P1276
-    .const 'Sub' $P1262 = "75_1278500533.96053" 
-    capture_lex $P1262
-    .const 'Sub' $P1249 = "74_1278500533.96053" 
-    capture_lex $P1249
-    .const 'Sub' $P1218 = "73_1278500533.96053" 
-    capture_lex $P1218
-    .const 'Sub' $P1187 = "72_1278500533.96053" 
-    capture_lex $P1187
-    .const 'Sub' $P1171 = "71_1278500533.96053" 
-    capture_lex $P1171
-    .const 'Sub' $P1155 = "70_1278500533.96053" 
-    capture_lex $P1155
-    .const 'Sub' $P1139 = "69_1278500533.96053" 
-    capture_lex $P1139
-    .const 'Sub' $P1123 = "68_1278500533.96053" 
-    capture_lex $P1123
-    .const 'Sub' $P1107 = "67_1278500533.96053" 
-    capture_lex $P1107
-    .const 'Sub' $P1091 = "66_1278500533.96053" 
-    capture_lex $P1091
-    .const 'Sub' $P1075 = "65_1278500533.96053" 
-    capture_lex $P1075
-    .const 'Sub' $P1051 = "64_1278500533.96053" 
-    capture_lex $P1051
-    .const 'Sub' $P1036 = "63_1278500533.96053" 
-    capture_lex $P1036
-    .const 'Sub' $P978 = "62_1278500533.96053" 
-    capture_lex $P978
-    .const 'Sub' $P957 = "61_1278500533.96053" 
-    capture_lex $P957
-    .const 'Sub' $P935 = "60_1278500533.96053" 
-    capture_lex $P935
-    .const 'Sub' $P925 = "59_1278500533.96053" 
-    capture_lex $P925
-    .const 'Sub' $P915 = "58_1278500533.96053" 
-    capture_lex $P915
-    .const 'Sub' $P905 = "57_1278500533.96053" 
-    capture_lex $P905
-    .const 'Sub' $P893 = "56_1278500533.96053" 
-    capture_lex $P893
-    .const 'Sub' $P881 = "55_1278500533.96053" 
-    capture_lex $P881
-    .const 'Sub' $P869 = "54_1278500533.96053" 
-    capture_lex $P869
-    .const 'Sub' $P857 = "53_1278500533.96053" 
-    capture_lex $P857
-    .const 'Sub' $P845 = "52_1278500533.96053" 
-    capture_lex $P845
-    .const 'Sub' $P833 = "51_1278500533.96053" 
-    capture_lex $P833
-    .const 'Sub' $P821 = "50_1278500533.96053" 
-    capture_lex $P821
-    .const 'Sub' $P809 = "49_1278500533.96053" 
-    capture_lex $P809
-    .const 'Sub' $P786 = "48_1278500533.96053" 
-    capture_lex $P786
-    .const 'Sub' $P763 = "47_1278500533.96053" 
-    capture_lex $P763
-    .const 'Sub' $P745 = "46_1278500533.96053" 
-    capture_lex $P745
-    .const 'Sub' $P735 = "45_1278500533.96053" 
-    capture_lex $P735
-    .const 'Sub' $P717 = "44_1278500533.96053" 
-    capture_lex $P717
-    .const 'Sub' $P644 = "42_1278500533.96053" 
-    capture_lex $P644
-    .const 'Sub' $P627 = "41_1278500533.96053" 
-    capture_lex $P627
-    .const 'Sub' $P612 = "40_1278500533.96053" 
-    capture_lex $P612
-    .const 'Sub' $P597 = "39_1278500533.96053" 
-    capture_lex $P597
-    .const 'Sub' $P571 = "38_1278500533.96053" 
-    capture_lex $P571
-    .const 'Sub' $P520 = "36_1278500533.96053" 
-    capture_lex $P520
-    .const 'Sub' $P452 = "34_1278500533.96053" 
-    capture_lex $P452
-    .const 'Sub' $P397 = "31_1278500533.96053" 
-    capture_lex $P397
-    .const 'Sub' $P382 = "30_1278500533.96053" 
-    capture_lex $P382
-    .const 'Sub' $P356 = "28_1278500533.96053" 
-    capture_lex $P356
-    .const 'Sub' $P339 = "27_1278500533.96053" 
-    capture_lex $P339
-    .const 'Sub' $P305 = "26_1278500533.96053" 
-    capture_lex $P305
-    .const 'Sub' $P50 = "13_1278500533.96053" 
-    capture_lex $P50
-    .const 'Sub' $P16 = "12_1278500533.96053" 
+    .const 'Sub' $P1571 = "89_1279529222.65073" 
+    capture_lex $P1571
+    .const 'Sub' $P1551 = "88_1279529222.65073" 
+    capture_lex $P1551
+    .const 'Sub' $P1519 = "87_1279529222.65073" 
+    capture_lex $P1519
+    .const 'Sub' $P1450 = "83_1279529222.65073" 
+    capture_lex $P1450
+    .const 'Sub' $P1382 = "81_1279529222.65073" 
+    capture_lex $P1382
+    .const 'Sub' $P1339 = "79_1279529222.65073" 
+    capture_lex $P1339
+    .const 'Sub' $P1325 = "78_1279529222.65073" 
+    capture_lex $P1325
+    .const 'Sub' $P1301 = "77_1279529222.65073" 
+    capture_lex $P1301
+    .const 'Sub' $P1283 = "76_1279529222.65073" 
+    capture_lex $P1283
+    .const 'Sub' $P1269 = "75_1279529222.65073" 
+    capture_lex $P1269
+    .const 'Sub' $P1256 = "74_1279529222.65073" 
+    capture_lex $P1256
+    .const 'Sub' $P1225 = "73_1279529222.65073" 
+    capture_lex $P1225
+    .const 'Sub' $P1194 = "72_1279529222.65073" 
+    capture_lex $P1194
+    .const 'Sub' $P1178 = "71_1279529222.65073" 
+    capture_lex $P1178
+    .const 'Sub' $P1162 = "70_1279529222.65073" 
+    capture_lex $P1162
+    .const 'Sub' $P1146 = "69_1279529222.65073" 
+    capture_lex $P1146
+    .const 'Sub' $P1130 = "68_1279529222.65073" 
+    capture_lex $P1130
+    .const 'Sub' $P1114 = "67_1279529222.65073" 
+    capture_lex $P1114
+    .const 'Sub' $P1098 = "66_1279529222.65073" 
+    capture_lex $P1098
+    .const 'Sub' $P1082 = "65_1279529222.65073" 
+    capture_lex $P1082
+    .const 'Sub' $P1058 = "64_1279529222.65073" 
+    capture_lex $P1058
+    .const 'Sub' $P1043 = "63_1279529222.65073" 
+    capture_lex $P1043
+    .const 'Sub' $P985 = "62_1279529222.65073" 
+    capture_lex $P985
+    .const 'Sub' $P964 = "61_1279529222.65073" 
+    capture_lex $P964
+    .const 'Sub' $P942 = "60_1279529222.65073" 
+    capture_lex $P942
+    .const 'Sub' $P932 = "59_1279529222.65073" 
+    capture_lex $P932
+    .const 'Sub' $P922 = "58_1279529222.65073" 
+    capture_lex $P922
+    .const 'Sub' $P912 = "57_1279529222.65073" 
+    capture_lex $P912
+    .const 'Sub' $P900 = "56_1279529222.65073" 
+    capture_lex $P900
+    .const 'Sub' $P888 = "55_1279529222.65073" 
+    capture_lex $P888
+    .const 'Sub' $P876 = "54_1279529222.65073" 
+    capture_lex $P876
+    .const 'Sub' $P864 = "53_1279529222.65073" 
+    capture_lex $P864
+    .const 'Sub' $P852 = "52_1279529222.65073" 
+    capture_lex $P852
+    .const 'Sub' $P840 = "51_1279529222.65073" 
+    capture_lex $P840
+    .const 'Sub' $P828 = "50_1279529222.65073" 
+    capture_lex $P828
+    .const 'Sub' $P816 = "49_1279529222.65073" 
+    capture_lex $P816
+    .const 'Sub' $P793 = "48_1279529222.65073" 
+    capture_lex $P793
+    .const 'Sub' $P770 = "47_1279529222.65073" 
+    capture_lex $P770
+    .const 'Sub' $P752 = "46_1279529222.65073" 
+    capture_lex $P752
+    .const 'Sub' $P742 = "45_1279529222.65073" 
+    capture_lex $P742
+    .const 'Sub' $P724 = "44_1279529222.65073" 
+    capture_lex $P724
+    .const 'Sub' $P651 = "42_1279529222.65073" 
+    capture_lex $P651
+    .const 'Sub' $P634 = "41_1279529222.65073" 
+    capture_lex $P634
+    .const 'Sub' $P619 = "40_1279529222.65073" 
+    capture_lex $P619
+    .const 'Sub' $P604 = "39_1279529222.65073" 
+    capture_lex $P604
+    .const 'Sub' $P578 = "38_1279529222.65073" 
+    capture_lex $P578
+    .const 'Sub' $P527 = "36_1279529222.65073" 
+    capture_lex $P527
+    .const 'Sub' $P459 = "34_1279529222.65073" 
+    capture_lex $P459
+    .const 'Sub' $P404 = "31_1279529222.65073" 
+    capture_lex $P404
+    .const 'Sub' $P389 = "30_1279529222.65073" 
+    capture_lex $P389
+    .const 'Sub' $P363 = "28_1279529222.65073" 
+    capture_lex $P363
+    .const 'Sub' $P346 = "27_1279529222.65073" 
+    capture_lex $P346
+    .const 'Sub' $P312 = "26_1279529222.65073" 
+    capture_lex $P312
+    .const 'Sub' $P57 = "13_1279529222.65073" 
+    capture_lex $P57
+    .const 'Sub' $P16 = "12_1279529222.65073" 
     capture_lex $P16
     get_global $P15, "@MODIFIERS"
-    unless_null $P15, vivify_94
+    unless_null $P15, vivify_95
     $P15 = root_new ['parrot';'ResizablePMCArray']
     set_global "@MODIFIERS", $P15
-  vivify_94:
-.annotate 'line', 494
-    .const 'Sub' $P16 = "12_1278500533.96053" 
-    newclosure $P49, $P16
-    .lex "buildsub", $P49
-.annotate 'line', 511
-    .const 'Sub' $P50 = "13_1278500533.96053" 
-    newclosure $P304, $P50
-    .lex "capnames", $P304
-.annotate 'line', 577
-    .const 'Sub' $P305 = "26_1278500533.96053" 
-    newclosure $P337, $P305
-    .lex "backmod", $P337
+  vivify_95:
+.annotate 'line', 487
+    .const 'Sub' $P16 = "12_1279529222.65073" 
+    newclosure $P56, $P16
+    .lex "buildsub", $P56
+.annotate 'line', 505
+    .const 'Sub' $P57 = "13_1279529222.65073" 
+    newclosure $P311, $P57
+    .lex "capnames", $P311
+.annotate 'line', 571
+    .const 'Sub' $P312 = "26_1279529222.65073" 
+    newclosure $P344, $P312
+    .lex "backmod", $P344
 .annotate 'line', 4
     $P0 = find_dynamic_lex "$*CTXSAVE"
     if null $P0 goto ctxsave_done
@@ -7527,4052 +7846,3978 @@
     unless $I0 goto ctxsave_done
     $P0."ctxsave"()
   ctxsave_done:
-    get_global $P338, "@MODIFIERS"
-.annotate 'line', 487
-    find_lex $P1572, "buildsub"
-    find_lex $P1573, "capnames"
-    find_lex $P1574, "backmod"
+    get_global $P345, "@MODIFIERS"
+.annotate 'line', 480
+    find_lex $P1548, "buildsub"
+    find_lex $P1549, "capnames"
+    find_lex $P1550, "backmod"
 .annotate 'line', 584
-    .const 'Sub' $P1575 = "89_1278500533.96053" 
-    newclosure $P1595, $P1575
+    .const 'Sub' $P1571 = "89_1279529222.65073" 
+    newclosure $P1617, $P1571
 .annotate 'line', 4
-    .return ($P1595)
-    .const 'Sub' $P1597 = "90_1278500533.96053" 
-    .return ($P1597)
+    .return ($P1617)
+    .const 'Sub' $P1619 = "91_1279529222.65073" 
+    .return ($P1619)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "" :load :init :subid("post93") :outer("11_1278500533.96053")
+.sub "" :load :init :subid("post94") :outer("11_1279529222.65073")
 .annotate 'line', 4
     get_hll_global $P14, ["Regex";"P6Regex";"Actions"], "_block13" 
     .local pmc block
     set block, $P14
 .annotate 'line', 7
 
-        $P1600 = new ['ResizablePMCArray']
+        $P1622 = new ['ResizablePMCArray']
         $P0 = new ['Hash']
-        push $P1600, $P0
+        push $P1622, $P0
     
-    set_global "@MODIFIERS", $P1600
+    set_global "@MODIFIERS", $P1622
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "buildsub"  :subid("12_1278500533.96053") :outer("11_1278500533.96053")
+.sub "buildsub"  :subid("12_1279529222.65073") :outer("11_1279529222.65073")
     .param pmc param_19
     .param pmc param_20 :optional
     .param int has_param_20 :opt_flag
-.annotate 'line', 494
+.annotate 'line', 487
     new $P18, 'ExceptionHandler'
     set_addr $P18, control_17
     $P18."handle_types"(.CONTROL_RETURN)
     push_eh $P18
     .lex "$rpast", param_19
-    if has_param_20, optparam_95
+    if has_param_20, optparam_96
     get_hll_global $P21, ["PAST"], "Block"
     $P22 = $P21."new"()
     set param_20, $P22
-  optparam_95:
+  optparam_96:
     .lex "$block", param_20
-.annotate 'line', 495
+.annotate 'line', 488
     $P23 = root_new ['parrot';'Hash']
     .lex "%capnames", $P23
     find_lex $P24, "$rpast"
     $P25 = "capnames"($P24, 0)
     store_lex "%capnames", $P25
-.annotate 'line', 496
+.annotate 'line', 489
     new $P26, "Integer"
     assign $P26, 0
     find_lex $P27, "%capnames"
-    unless_null $P27, vivify_96
+    unless_null $P27, vivify_97
     $P27 = root_new ['parrot';'Hash']
     store_lex "%capnames", $P27
-  vivify_96:
+  vivify_97:
     set $P27[""], $P26
-.annotate 'line', 497
+.annotate 'line', 490
     get_hll_global $P28, ["PAST"], "Regex"
-.annotate 'line', 498
+.annotate 'line', 491
     get_hll_global $P29, ["PAST"], "Regex"
     $P30 = $P29."new"("scan" :named("pasttype"))
     find_lex $P31, "$rpast"
-.annotate 'line', 500
+.annotate 'line', 493
     get_hll_global $P32, ["PAST"], "Regex"
-    $P33 = $P32."new"("pass" :named("pasttype"))
-    find_lex $P34, "%capnames"
-    $P35 = $P28."new"($P30, $P31, $P33, "concat" :named("pasttype"), $P34 :named("capnames"))
-.annotate 'line', 497
-    store_lex "$rpast", $P35
-.annotate 'line', 504
-    find_lex $P37, "$block"
-    $P38 = $P37."symbol"(unicode:"$\x{a2}")
-    if $P38, unless_36_end
-    find_lex $P39, "$block"
-    $P39."symbol"(unicode:"$\x{a2}", "lexical" :named("scope"))
-  unless_36_end:
-.annotate 'line', 505
-    find_lex $P41, "$block"
-    $P42 = $P41."symbol"("$/")
-    if $P42, unless_40_end
-    find_lex $P43, "$block"
-    $P43."symbol"("$/", "lexical" :named("scope"))
-  unless_40_end:
-.annotate 'line', 506
+.annotate 'line', 494
+    get_global $P35, "@MODIFIERS"
+    unless_null $P35, vivify_98
+    $P35 = root_new ['parrot';'ResizablePMCArray']
+  vivify_98:
+    set $P36, $P35[0]
+    unless_null $P36, vivify_99
+    $P36 = root_new ['parrot';'Hash']
+  vivify_99:
+    set $P37, $P36["r"]
+    unless_null $P37, vivify_100
+    new $P37, "Undef"
+  vivify_100:
+    if $P37, if_34
+    new $P39, "String"
+    assign $P39, "g"
+    set $P33, $P39
+    goto if_34_end
+  if_34:
+    new $P38, "String"
+    assign $P38, "r"
+    set $P33, $P38
+  if_34_end:
+    $P40 = $P32."new"("pass" :named("pasttype"), $P33 :named("backtrack"))
+.annotate 'line', 493
+    find_lex $P41, "%capnames"
+    $P42 = $P28."new"($P30, $P31, $P40, "concat" :named("pasttype"), $P41 :named("capnames"))
+.annotate 'line', 490
+    store_lex "$rpast", $P42
+.annotate 'line', 498
     find_lex $P44, "$block"
-    find_lex $P45, "$rpast"
-    $P44."push"($P45)
-.annotate 'line', 507
+    $P45 = $P44."symbol"(unicode:"$\x{a2}")
+    if $P45, unless_43_end
     find_lex $P46, "$block"
-    $P46."blocktype"("method")
-    find_lex $P47, "$block"
-.annotate 'line', 494
-    .return ($P47)
+    $P46."symbol"(unicode:"$\x{a2}", "lexical" :named("scope"))
+  unless_43_end:
+.annotate 'line', 499
+    find_lex $P48, "$block"
+    $P49 = $P48."symbol"("$/")
+    if $P49, unless_47_end
+    find_lex $P50, "$block"
+    $P50."symbol"("$/", "lexical" :named("scope"))
+  unless_47_end:
+.annotate 'line', 500
+    find_lex $P51, "$block"
+    find_lex $P52, "$rpast"
+    $P51."push"($P52)
+.annotate 'line', 501
+    find_lex $P53, "$block"
+    $P53."blocktype"("method")
+    find_lex $P54, "$block"
+.annotate 'line', 487
+    .return ($P54)
   control_17:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P48, exception, "payload"
-    .return ($P48)
+    getattribute $P55, exception, "payload"
+    .return ($P55)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "capnames"  :subid("13_1278500533.96053") :outer("11_1278500533.96053")
-    .param pmc param_53
-    .param pmc param_54
-.annotate 'line', 511
-    .const 'Sub' $P279 = "24_1278500533.96053" 
-    capture_lex $P279
-    .const 'Sub' $P216 = "21_1278500533.96053" 
-    capture_lex $P216
-    .const 'Sub' $P174 = "19_1278500533.96053" 
-    capture_lex $P174
-    .const 'Sub' $P132 = "17_1278500533.96053" 
-    capture_lex $P132
-    .const 'Sub' $P65 = "14_1278500533.96053" 
-    capture_lex $P65
-    new $P52, 'ExceptionHandler'
-    set_addr $P52, control_51
-    $P52."handle_types"(.CONTROL_RETURN)
-    push_eh $P52
-    .lex "$ast", param_53
-    .lex "$count", param_54
-.annotate 'line', 512
-    $P55 = root_new ['parrot';'Hash']
-    .lex "%capnames", $P55
-.annotate 'line', 513
-    new $P56, "Undef"
-    .lex "$pasttype", $P56
-.annotate 'line', 511
-    find_lex $P57, "%capnames"
-.annotate 'line', 513
-    find_lex $P58, "$ast"
-    $P59 = $P58."pasttype"()
-    store_lex "$pasttype", $P59
-.annotate 'line', 514
-    find_lex $P61, "$pasttype"
-    set $S62, $P61
-    iseq $I63, $S62, "alt"
-    if $I63, if_60
-.annotate 'line', 527
-    find_lex $P123, "$pasttype"
-    set $S124, $P123
-    iseq $I125, $S124, "concat"
-    if $I125, if_122
-.annotate 'line', 536
-    find_lex $P167, "$pasttype"
-    set $S168, $P167
-    iseq $I169, $S168, "subrule"
-    if $I169, if_166
-    new $P165, 'Integer'
-    set $P165, $I169
-    goto if_166_end
-  if_166:
-    find_lex $P170, "$ast"
-    $S171 = $P170."subtype"()
-    iseq $I172, $S171, "capture"
-    new $P165, 'Integer'
-    set $P165, $I172
-  if_166_end:
-    if $P165, if_164
-.annotate 'line', 549
-    find_lex $P212, "$pasttype"
-    set $S213, $P212
-    iseq $I214, $S213, "subcapture"
-    if $I214, if_211
-.annotate 'line', 566
-    find_lex $P275, "$pasttype"
-    set $S276, $P275
-    iseq $I277, $S276, "quant"
-    unless $I277, if_274_end
-    .const 'Sub' $P279 = "24_1278500533.96053" 
-    capture_lex $P279
-    $P279()
-  if_274_end:
-    goto if_211_end
-  if_211:
-.annotate 'line', 549
-    .const 'Sub' $P216 = "21_1278500533.96053" 
-    capture_lex $P216
-    $P216()
-  if_211_end:
-    goto if_164_end
-  if_164:
-.annotate 'line', 536
-    .const 'Sub' $P174 = "19_1278500533.96053" 
-    capture_lex $P174
-    $P174()
-  if_164_end:
-    goto if_122_end
-  if_122:
-.annotate 'line', 528
-    find_lex $P127, "$ast"
-    $P128 = $P127."list"()
-    defined $I129, $P128
-    unless $I129, for_undef_117
-    iter $P126, $P128
-    new $P162, 'ExceptionHandler'
-    set_addr $P162, loop161_handler
-    $P162."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P162
-  loop161_test:
-    unless $P126, loop161_done
-    shift $P130, $P126
-  loop161_redo:
-    .const 'Sub' $P132 = "17_1278500533.96053" 
-    capture_lex $P132
-    $P132($P130)
-  loop161_next:
-    goto loop161_test
-  loop161_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P163, exception, 'type'
-    eq $P163, .CONTROL_LOOP_NEXT, loop161_next
-    eq $P163, .CONTROL_LOOP_REDO, loop161_redo
-  loop161_done:
+.sub "capnames"  :subid("13_1279529222.65073") :outer("11_1279529222.65073")
+    .param pmc param_60
+    .param pmc param_61
+.annotate 'line', 505
+    .const 'Sub' $P286 = "24_1279529222.65073" 
+    capture_lex $P286
+    .const 'Sub' $P223 = "21_1279529222.65073" 
+    capture_lex $P223
+    .const 'Sub' $P181 = "19_1279529222.65073" 
+    capture_lex $P181
+    .const 'Sub' $P139 = "17_1279529222.65073" 
+    capture_lex $P139
+    .const 'Sub' $P72 = "14_1279529222.65073" 
+    capture_lex $P72
+    new $P59, 'ExceptionHandler'
+    set_addr $P59, control_58
+    $P59."handle_types"(.CONTROL_RETURN)
+    push_eh $P59
+    .lex "$ast", param_60
+    .lex "$count", param_61
+.annotate 'line', 506
+    $P62 = root_new ['parrot';'Hash']
+    .lex "%capnames", $P62
+.annotate 'line', 507
+    new $P63, "Undef"
+    .lex "$pasttype", $P63
+.annotate 'line', 505
+    find_lex $P64, "%capnames"
+.annotate 'line', 507
+    find_lex $P65, "$ast"
+    $P66 = $P65."pasttype"()
+    store_lex "$pasttype", $P66
+.annotate 'line', 508
+    find_lex $P68, "$pasttype"
+    set $S69, $P68
+    iseq $I70, $S69, "alt"
+    if $I70, if_67
+.annotate 'line', 521
+    find_lex $P130, "$pasttype"
+    set $S131, $P130
+    iseq $I132, $S131, "concat"
+    if $I132, if_129
+.annotate 'line', 530
+    find_lex $P174, "$pasttype"
+    set $S175, $P174
+    iseq $I176, $S175, "subrule"
+    if $I176, if_173
+    new $P172, 'Integer'
+    set $P172, $I176
+    goto if_173_end
+  if_173:
+    find_lex $P177, "$ast"
+    $S178 = $P177."subtype"()
+    iseq $I179, $S178, "capture"
+    new $P172, 'Integer'
+    set $P172, $I179
+  if_173_end:
+    if $P172, if_171
+.annotate 'line', 543
+    find_lex $P219, "$pasttype"
+    set $S220, $P219
+    iseq $I221, $S220, "subcapture"
+    if $I221, if_218
+.annotate 'line', 560
+    find_lex $P282, "$pasttype"
+    set $S283, $P282
+    iseq $I284, $S283, "quant"
+    unless $I284, if_281_end
+    .const 'Sub' $P286 = "24_1279529222.65073" 
+    capture_lex $P286
+    $P286()
+  if_281_end:
+    goto if_218_end
+  if_218:
+.annotate 'line', 543
+    .const 'Sub' $P223 = "21_1279529222.65073" 
+    capture_lex $P223
+    $P223()
+  if_218_end:
+    goto if_171_end
+  if_171:
+.annotate 'line', 530
+    .const 'Sub' $P181 = "19_1279529222.65073" 
+    capture_lex $P181
+    $P181()
+  if_171_end:
+    goto if_129_end
+  if_129:
+.annotate 'line', 522
+    find_lex $P134, "$ast"
+    $P135 = $P134."list"()
+    defined $I136, $P135
+    unless $I136, for_undef_121
+    iter $P133, $P135
+    new $P169, 'ExceptionHandler'
+    set_addr $P169, loop168_handler
+    $P169."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P169
+  loop168_test:
+    unless $P133, loop168_done
+    shift $P137, $P133
+  loop168_redo:
+    .const 'Sub' $P139 = "17_1279529222.65073" 
+    capture_lex $P139
+    $P139($P137)
+  loop168_next:
+    goto loop168_test
+  loop168_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P170, exception, 'type'
+    eq $P170, .CONTROL_LOOP_NEXT, loop168_next
+    eq $P170, .CONTROL_LOOP_REDO, loop168_redo
+  loop168_done:
     pop_eh 
-  for_undef_117:
-  if_122_end:
-.annotate 'line', 527
-    goto if_60_end
-  if_60:
-.annotate 'line', 514
-    .const 'Sub' $P65 = "14_1278500533.96053" 
-    capture_lex $P65
-    $P65()
-  if_60_end:
-.annotate 'line', 573
-    find_lex $P300, "$count"
-    find_lex $P301, "%capnames"
-    unless_null $P301, vivify_137
-    $P301 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P301
-  vivify_137:
-    set $P301[""], $P300
-    find_lex $P302, "%capnames"
-.annotate 'line', 511
-    .return ($P302)
-  control_51:
+  for_undef_121:
+  if_129_end:
+.annotate 'line', 521
+    goto if_67_end
+  if_67:
+.annotate 'line', 508
+    .const 'Sub' $P72 = "14_1279529222.65073" 
+    capture_lex $P72
+    $P72()
+  if_67_end:
+.annotate 'line', 567
+    find_lex $P307, "$count"
+    find_lex $P308, "%capnames"
+    unless_null $P308, vivify_141
+    $P308 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P308
+  vivify_141:
+    set $P308[""], $P307
+    find_lex $P309, "%capnames"
+.annotate 'line', 505
+    .return ($P309)
+  control_58:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P303, exception, "payload"
-    .return ($P303)
+    getattribute $P310, exception, "payload"
+    .return ($P310)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block278"  :anon :subid("24_1278500533.96053") :outer("13_1278500533.96053")
-.annotate 'line', 566
-    .const 'Sub' $P290 = "25_1278500533.96053" 
-    capture_lex $P290
-.annotate 'line', 567
-    $P280 = root_new ['parrot';'Hash']
-    .lex "%astcap", $P280
-    find_lex $P281, "$ast"
-    unless_null $P281, vivify_97
-    $P281 = root_new ['parrot';'ResizablePMCArray']
-  vivify_97:
-    set $P282, $P281[0]
-    unless_null $P282, vivify_98
-    new $P282, "Undef"
-  vivify_98:
-    find_lex $P283, "$count"
-    $P284 = "capnames"($P282, $P283)
-    store_lex "%astcap", $P284
-.annotate 'line', 568
-    find_lex $P286, "%astcap"
-    defined $I287, $P286
-    unless $I287, for_undef_99
-    iter $P285, $P286
-    new $P296, 'ExceptionHandler'
-    set_addr $P296, loop295_handler
-    $P296."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P296
-  loop295_test:
-    unless $P285, loop295_done
-    shift $P288, $P285
-  loop295_redo:
-    .const 'Sub' $P290 = "25_1278500533.96053" 
-    capture_lex $P290
-    $P290($P288)
-  loop295_next:
-    goto loop295_test
-  loop295_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P297, exception, 'type'
-    eq $P297, .CONTROL_LOOP_NEXT, loop295_next
-    eq $P297, .CONTROL_LOOP_REDO, loop295_redo
-  loop295_done:
-    pop_eh 
-  for_undef_99:
-.annotate 'line', 571
-    find_lex $P298, "%astcap"
-    unless_null $P298, vivify_101
-    $P298 = root_new ['parrot';'Hash']
+.sub "_block285"  :anon :subid("24_1279529222.65073") :outer("13_1279529222.65073")
+.annotate 'line', 560
+    .const 'Sub' $P297 = "25_1279529222.65073" 
+    capture_lex $P297
+.annotate 'line', 561
+    $P287 = root_new ['parrot';'Hash']
+    .lex "%astcap", $P287
+    find_lex $P288, "$ast"
+    unless_null $P288, vivify_101
+    $P288 = root_new ['parrot';'ResizablePMCArray']
   vivify_101:
-    set $P299, $P298[""]
-    unless_null $P299, vivify_102
-    new $P299, "Undef"
+    set $P289, $P288[0]
+    unless_null $P289, vivify_102
+    new $P289, "Undef"
   vivify_102:
-    store_lex "$count", $P299
-.annotate 'line', 566
-    .return ($P299)
+    find_lex $P290, "$count"
+    $P291 = "capnames"($P289, $P290)
+    store_lex "%astcap", $P291
+.annotate 'line', 562
+    find_lex $P293, "%astcap"
+    defined $I294, $P293
+    unless $I294, for_undef_103
+    iter $P292, $P293
+    new $P303, 'ExceptionHandler'
+    set_addr $P303, loop302_handler
+    $P303."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P303
+  loop302_test:
+    unless $P292, loop302_done
+    shift $P295, $P292
+  loop302_redo:
+    .const 'Sub' $P297 = "25_1279529222.65073" 
+    capture_lex $P297
+    $P297($P295)
+  loop302_next:
+    goto loop302_test
+  loop302_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P304, exception, 'type'
+    eq $P304, .CONTROL_LOOP_NEXT, loop302_next
+    eq $P304, .CONTROL_LOOP_REDO, loop302_redo
+  loop302_done:
+    pop_eh 
+  for_undef_103:
+.annotate 'line', 565
+    find_lex $P305, "%astcap"
+    unless_null $P305, vivify_105
+    $P305 = root_new ['parrot';'Hash']
+  vivify_105:
+    set $P306, $P305[""]
+    unless_null $P306, vivify_106
+    new $P306, "Undef"
+  vivify_106:
+    store_lex "$count", $P306
+.annotate 'line', 560
+    .return ($P306)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block289"  :anon :subid("25_1278500533.96053") :outer("24_1278500533.96053")
-    .param pmc param_291
-.annotate 'line', 568
-    .lex "$_", param_291
-.annotate 'line', 569
-    new $P292, "Integer"
-    assign $P292, 2
-    find_lex $P293, "$_"
-    find_lex $P294, "%capnames"
-    unless_null $P294, vivify_100
-    $P294 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P294
-  vivify_100:
-    set $P294[$P293], $P292
-.annotate 'line', 568
-    .return ($P292)
+.sub "_block296"  :anon :subid("25_1279529222.65073") :outer("24_1279529222.65073")
+    .param pmc param_298
+.annotate 'line', 562
+    .lex "$_", param_298
+.annotate 'line', 563
+    new $P299, "Integer"
+    assign $P299, 2
+    find_lex $P300, "$_"
+    find_lex $P301, "%capnames"
+    unless_null $P301, vivify_104
+    $P301 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P301
+  vivify_104:
+    set $P301[$P300], $P299
+.annotate 'line', 562
+    .return ($P299)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block215"  :anon :subid("21_1278500533.96053") :outer("13_1278500533.96053")
-.annotate 'line', 549
-    .const 'Sub' $P256 = "23_1278500533.96053" 
-    capture_lex $P256
-    .const 'Sub' $P228 = "22_1278500533.96053" 
-    capture_lex $P228
-.annotate 'line', 550
-    new $P217, "Undef"
-    .lex "$name", $P217
-.annotate 'line', 551
-    $P218 = root_new ['parrot';'ResizablePMCArray']
-    .lex "@names", $P218
-.annotate 'line', 560
-    $P219 = root_new ['parrot';'Hash']
-    .lex "%x", $P219
-.annotate 'line', 550
-    find_lex $P220, "$ast"
-    $P221 = $P220."name"()
-    store_lex "$name", $P221
-.annotate 'line', 551
+.sub "_block222"  :anon :subid("21_1279529222.65073") :outer("13_1279529222.65073")
+.annotate 'line', 543
+    .const 'Sub' $P263 = "23_1279529222.65073" 
+    capture_lex $P263
+    .const 'Sub' $P235 = "22_1279529222.65073" 
+    capture_lex $P235
+.annotate 'line', 544
+    new $P224, "Undef"
+    .lex "$name", $P224
+.annotate 'line', 545
+    $P225 = root_new ['parrot';'ResizablePMCArray']
+    .lex "@names", $P225
+.annotate 'line', 554
+    $P226 = root_new ['parrot';'Hash']
+    .lex "%x", $P226
+.annotate 'line', 544
+    find_lex $P227, "$ast"
+    $P228 = $P227."name"()
+    store_lex "$name", $P228
+.annotate 'line', 545
 
             $P0 = find_lex '$name'
             $S0 = $P0
-            $P222 = split '=', $S0
+            $P229 = split '=', $S0
         
-    store_lex "@names", $P222
-.annotate 'line', 556
-    find_lex $P224, "@names"
-    defined $I225, $P224
-    unless $I225, for_undef_103
-    iter $P223, $P224
-    new $P245, 'ExceptionHandler'
-    set_addr $P245, loop244_handler
-    $P245."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P245
-  loop244_test:
-    unless $P223, loop244_done
-    shift $P226, $P223
-  loop244_redo:
-    .const 'Sub' $P228 = "22_1278500533.96053" 
-    capture_lex $P228
-    $P228($P226)
-  loop244_next:
-    goto loop244_test
-  loop244_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P246, exception, 'type'
-    eq $P246, .CONTROL_LOOP_NEXT, loop244_next
-    eq $P246, .CONTROL_LOOP_REDO, loop244_redo
-  loop244_done:
-    pop_eh 
-  for_undef_103:
-.annotate 'line', 560
-    find_lex $P247, "$ast"
-    unless_null $P247, vivify_105
-    $P247 = root_new ['parrot';'ResizablePMCArray']
-  vivify_105:
-    set $P248, $P247[0]
-    unless_null $P248, vivify_106
-    new $P248, "Undef"
-  vivify_106:
-    find_lex $P249, "$count"
-    $P250 = "capnames"($P248, $P249)
-    store_lex "%x", $P250
-.annotate 'line', 561
-    find_lex $P252, "%x"
-    defined $I253, $P252
-    unless $I253, for_undef_107
-    iter $P251, $P252
-    new $P270, 'ExceptionHandler'
-    set_addr $P270, loop269_handler
-    $P270."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P270
-  loop269_test:
-    unless $P251, loop269_done
-    shift $P254, $P251
-  loop269_redo:
-    .const 'Sub' $P256 = "23_1278500533.96053" 
-    capture_lex $P256
-    $P256($P254)
-  loop269_next:
-    goto loop269_test
-  loop269_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P271, exception, 'type'
-    eq $P271, .CONTROL_LOOP_NEXT, loop269_next
-    eq $P271, .CONTROL_LOOP_REDO, loop269_redo
-  loop269_done:
+    store_lex "@names", $P229
+.annotate 'line', 550
+    find_lex $P231, "@names"
+    defined $I232, $P231
+    unless $I232, for_undef_107
+    iter $P230, $P231
+    new $P252, 'ExceptionHandler'
+    set_addr $P252, loop251_handler
+    $P252."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P252
+  loop251_test:
+    unless $P230, loop251_done
+    shift $P233, $P230
+  loop251_redo:
+    .const 'Sub' $P235 = "22_1279529222.65073" 
+    capture_lex $P235
+    $P235($P233)
+  loop251_next:
+    goto loop251_test
+  loop251_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P253, exception, 'type'
+    eq $P253, .CONTROL_LOOP_NEXT, loop251_next
+    eq $P253, .CONTROL_LOOP_REDO, loop251_redo
+  loop251_done:
     pop_eh 
   for_undef_107:
-.annotate 'line', 564
-    find_lex $P272, "%x"
-    unless_null $P272, vivify_113
-    $P272 = root_new ['parrot';'Hash']
-  vivify_113:
-    set $P273, $P272[""]
-    unless_null $P273, vivify_114
-    new $P273, "Undef"
-  vivify_114:
-    store_lex "$count", $P273
-.annotate 'line', 549
-    .return ($P273)
+.annotate 'line', 554
+    find_lex $P254, "$ast"
+    unless_null $P254, vivify_109
+    $P254 = root_new ['parrot';'ResizablePMCArray']
+  vivify_109:
+    set $P255, $P254[0]
+    unless_null $P255, vivify_110
+    new $P255, "Undef"
+  vivify_110:
+    find_lex $P256, "$count"
+    $P257 = "capnames"($P255, $P256)
+    store_lex "%x", $P257
+.annotate 'line', 555
+    find_lex $P259, "%x"
+    defined $I260, $P259
+    unless $I260, for_undef_111
+    iter $P258, $P259
+    new $P277, 'ExceptionHandler'
+    set_addr $P277, loop276_handler
+    $P277."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P277
+  loop276_test:
+    unless $P258, loop276_done
+    shift $P261, $P258
+  loop276_redo:
+    .const 'Sub' $P263 = "23_1279529222.65073" 
+    capture_lex $P263
+    $P263($P261)
+  loop276_next:
+    goto loop276_test
+  loop276_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P278, exception, 'type'
+    eq $P278, .CONTROL_LOOP_NEXT, loop276_next
+    eq $P278, .CONTROL_LOOP_REDO, loop276_redo
+  loop276_done:
+    pop_eh 
+  for_undef_111:
+.annotate 'line', 558
+    find_lex $P279, "%x"
+    unless_null $P279, vivify_117
+    $P279 = root_new ['parrot';'Hash']
+  vivify_117:
+    set $P280, $P279[""]
+    unless_null $P280, vivify_118
+    new $P280, "Undef"
+  vivify_118:
+    store_lex "$count", $P280
+.annotate 'line', 543
+    .return ($P280)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block227"  :anon :subid("22_1278500533.96053") :outer("21_1278500533.96053")
-    .param pmc param_229
-.annotate 'line', 556
-    .lex "$_", param_229
-.annotate 'line', 557
-    find_lex $P233, "$_"
-    set $S234, $P233
-    iseq $I235, $S234, "0"
-    unless $I235, unless_232
-    new $P231, 'Integer'
-    set $P231, $I235
-    goto unless_232_end
-  unless_232:
-    find_lex $P236, "$_"
-    set $N237, $P236
-    isgt $I238, $N237, 0.0
-    new $P231, 'Integer'
-    set $P231, $I238
-  unless_232_end:
-    unless $P231, if_230_end
-    find_lex $P239, "$_"
-    add $P240, $P239, 1
-    store_lex "$count", $P240
-  if_230_end:
-.annotate 'line', 558
-    new $P241, "Integer"
-    assign $P241, 1
-    find_lex $P242, "$_"
-    find_lex $P243, "%capnames"
-    unless_null $P243, vivify_104
-    $P243 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P243
-  vivify_104:
-    set $P243[$P242], $P241
-.annotate 'line', 556
-    .return ($P241)
+.sub "_block234"  :anon :subid("22_1279529222.65073") :outer("21_1279529222.65073")
+    .param pmc param_236
+.annotate 'line', 550
+    .lex "$_", param_236
+.annotate 'line', 551
+    find_lex $P240, "$_"
+    set $S241, $P240
+    iseq $I242, $S241, "0"
+    unless $I242, unless_239
+    new $P238, 'Integer'
+    set $P238, $I242
+    goto unless_239_end
+  unless_239:
+    find_lex $P243, "$_"
+    set $N244, $P243
+    isgt $I245, $N244, 0.0
+    new $P238, 'Integer'
+    set $P238, $I245
+  unless_239_end:
+    unless $P238, if_237_end
+    find_lex $P246, "$_"
+    add $P247, $P246, 1
+    store_lex "$count", $P247
+  if_237_end:
+.annotate 'line', 552
+    new $P248, "Integer"
+    assign $P248, 1
+    find_lex $P249, "$_"
+    find_lex $P250, "%capnames"
+    unless_null $P250, vivify_108
+    $P250 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P250
+  vivify_108:
+    set $P250[$P249], $P248
+.annotate 'line', 550
+    .return ($P248)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block255"  :anon :subid("23_1278500533.96053") :outer("21_1278500533.96053")
-    .param pmc param_257
-.annotate 'line', 561
-    .lex "$_", param_257
-.annotate 'line', 562
-    find_lex $P258, "$_"
-    find_lex $P259, "%capnames"
-    unless_null $P259, vivify_108
-    $P259 = root_new ['parrot';'Hash']
-  vivify_108:
-    set $P260, $P259[$P258]
-    unless_null $P260, vivify_109
-    new $P260, "Undef"
-  vivify_109:
-    set $N261, $P260
-    new $P262, 'Float'
-    set $P262, $N261
-    find_lex $P263, "$_"
-    find_lex $P264, "%x"
-    unless_null $P264, vivify_110
-    $P264 = root_new ['parrot';'Hash']
-  vivify_110:
-    set $P265, $P264[$P263]
-    unless_null $P265, vivify_111
-    new $P265, "Undef"
-  vivify_111:
-    add $P266, $P262, $P265
-    find_lex $P267, "$_"
-    find_lex $P268, "%capnames"
-    unless_null $P268, vivify_112
-    $P268 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P268
+.sub "_block262"  :anon :subid("23_1279529222.65073") :outer("21_1279529222.65073")
+    .param pmc param_264
+.annotate 'line', 555
+    .lex "$_", param_264
+.annotate 'line', 556
+    find_lex $P265, "$_"
+    find_lex $P266, "%capnames"
+    unless_null $P266, vivify_112
+    $P266 = root_new ['parrot';'Hash']
   vivify_112:
-    set $P268[$P267], $P266
-.annotate 'line', 561
-    .return ($P266)
+    set $P267, $P266[$P265]
+    unless_null $P267, vivify_113
+    new $P267, "Undef"
+  vivify_113:
+    set $N268, $P267
+    new $P269, 'Float'
+    set $P269, $N268
+    find_lex $P270, "$_"
+    find_lex $P271, "%x"
+    unless_null $P271, vivify_114
+    $P271 = root_new ['parrot';'Hash']
+  vivify_114:
+    set $P272, $P271[$P270]
+    unless_null $P272, vivify_115
+    new $P272, "Undef"
+  vivify_115:
+    add $P273, $P269, $P272
+    find_lex $P274, "$_"
+    find_lex $P275, "%capnames"
+    unless_null $P275, vivify_116
+    $P275 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P275
+  vivify_116:
+    set $P275[$P274], $P273
+.annotate 'line', 555
+    .return ($P273)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block173"  :anon :subid("19_1278500533.96053") :outer("13_1278500533.96053")
-.annotate 'line', 536
-    .const 'Sub' $P192 = "20_1278500533.96053" 
-    capture_lex $P192
-.annotate 'line', 537
-    new $P175, "Undef"
-    .lex "$name", $P175
-.annotate 'line', 539
-    $P176 = root_new ['parrot';'ResizablePMCArray']
-    .lex "@names", $P176
-.annotate 'line', 537
-    find_lex $P177, "$ast"
-    $P178 = $P177."name"()
-    store_lex "$name", $P178
-.annotate 'line', 538
-    find_lex $P180, "$name"
-    set $S181, $P180
-    iseq $I182, $S181, ""
-    unless $I182, if_179_end
-    find_lex $P183, "$count"
-    store_lex "$name", $P183
+.sub "_block180"  :anon :subid("19_1279529222.65073") :outer("13_1279529222.65073")
+.annotate 'line', 530
+    .const 'Sub' $P199 = "20_1279529222.65073" 
+    capture_lex $P199
+.annotate 'line', 531
+    new $P182, "Undef"
+    .lex "$name", $P182
+.annotate 'line', 533
+    $P183 = root_new ['parrot';'ResizablePMCArray']
+    .lex "@names", $P183
+.annotate 'line', 531
     find_lex $P184, "$ast"
-    find_lex $P185, "$name"
-    $P184."name"($P185)
-  if_179_end:
-.annotate 'line', 539
+    $P185 = $P184."name"()
+    store_lex "$name", $P185
+.annotate 'line', 532
+    find_lex $P187, "$name"
+    set $S188, $P187
+    iseq $I189, $S188, ""
+    unless $I189, if_186_end
+    find_lex $P190, "$count"
+    store_lex "$name", $P190
+    find_lex $P191, "$ast"
+    find_lex $P192, "$name"
+    $P191."name"($P192)
+  if_186_end:
+.annotate 'line', 533
 
             $P0 = find_lex '$name'
             $S0 = $P0
-            $P186 = split '=', $S0
+            $P193 = split '=', $S0
         
-    store_lex "@names", $P186
-.annotate 'line', 544
-    find_lex $P188, "@names"
-    defined $I189, $P188
-    unless $I189, for_undef_115
-    iter $P187, $P188
-    new $P209, 'ExceptionHandler'
-    set_addr $P209, loop208_handler
-    $P209."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P209
-  loop208_test:
-    unless $P187, loop208_done
-    shift $P190, $P187
-  loop208_redo:
-    .const 'Sub' $P192 = "20_1278500533.96053" 
-    capture_lex $P192
-    $P192($P190)
-  loop208_next:
-    goto loop208_test
-  loop208_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P210, exception, 'type'
-    eq $P210, .CONTROL_LOOP_NEXT, loop208_next
-    eq $P210, .CONTROL_LOOP_REDO, loop208_redo
-  loop208_done:
+    store_lex "@names", $P193
+.annotate 'line', 538
+    find_lex $P195, "@names"
+    defined $I196, $P195
+    unless $I196, for_undef_119
+    iter $P194, $P195
+    new $P216, 'ExceptionHandler'
+    set_addr $P216, loop215_handler
+    $P216."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P216
+  loop215_test:
+    unless $P194, loop215_done
+    shift $P197, $P194
+  loop215_redo:
+    .const 'Sub' $P199 = "20_1279529222.65073" 
+    capture_lex $P199
+    $P199($P197)
+  loop215_next:
+    goto loop215_test
+  loop215_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P217, exception, 'type'
+    eq $P217, .CONTROL_LOOP_NEXT, loop215_next
+    eq $P217, .CONTROL_LOOP_REDO, loop215_redo
+  loop215_done:
     pop_eh 
-  for_undef_115:
-.annotate 'line', 536
-    .return ($P187)
+  for_undef_119:
+.annotate 'line', 530
+    .return ($P194)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block191"  :anon :subid("20_1278500533.96053") :outer("19_1278500533.96053")
-    .param pmc param_193
-.annotate 'line', 544
-    .lex "$_", param_193
-.annotate 'line', 545
-    find_lex $P197, "$_"
-    set $S198, $P197
-    iseq $I199, $S198, "0"
-    unless $I199, unless_196
-    new $P195, 'Integer'
-    set $P195, $I199
-    goto unless_196_end
-  unless_196:
-    find_lex $P200, "$_"
-    set $N201, $P200
-    isgt $I202, $N201, 0.0
-    new $P195, 'Integer'
-    set $P195, $I202
-  unless_196_end:
-    unless $P195, if_194_end
-    find_lex $P203, "$_"
-    add $P204, $P203, 1
-    store_lex "$count", $P204
-  if_194_end:
-.annotate 'line', 546
-    new $P205, "Integer"
-    assign $P205, 1
-    find_lex $P206, "$_"
-    find_lex $P207, "%capnames"
-    unless_null $P207, vivify_116
-    $P207 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P207
-  vivify_116:
-    set $P207[$P206], $P205
-.annotate 'line', 544
-    .return ($P205)
+.sub "_block198"  :anon :subid("20_1279529222.65073") :outer("19_1279529222.65073")
+    .param pmc param_200
+.annotate 'line', 538
+    .lex "$_", param_200
+.annotate 'line', 539
+    find_lex $P204, "$_"
+    set $S205, $P204
+    iseq $I206, $S205, "0"
+    unless $I206, unless_203
+    new $P202, 'Integer'
+    set $P202, $I206
+    goto unless_203_end
+  unless_203:
+    find_lex $P207, "$_"
+    set $N208, $P207
+    isgt $I209, $N208, 0.0
+    new $P202, 'Integer'
+    set $P202, $I209
+  unless_203_end:
+    unless $P202, if_201_end
+    find_lex $P210, "$_"
+    add $P211, $P210, 1
+    store_lex "$count", $P211
+  if_201_end:
+.annotate 'line', 540
+    new $P212, "Integer"
+    assign $P212, 1
+    find_lex $P213, "$_"
+    find_lex $P214, "%capnames"
+    unless_null $P214, vivify_120
+    $P214 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P214
+  vivify_120:
+    set $P214[$P213], $P212
+.annotate 'line', 538
+    .return ($P212)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block131"  :anon :subid("17_1278500533.96053") :outer("13_1278500533.96053")
-    .param pmc param_134
-.annotate 'line', 528
-    .const 'Sub' $P143 = "18_1278500533.96053" 
-    capture_lex $P143
-.annotate 'line', 529
-    $P133 = root_new ['parrot';'Hash']
-    .lex "%x", $P133
-    .lex "$_", param_134
-    find_lex $P135, "$_"
-    find_lex $P136, "$count"
-    $P137 = "capnames"($P135, $P136)
-    store_lex "%x", $P137
-.annotate 'line', 530
-    find_lex $P139, "%x"
-    defined $I140, $P139
-    unless $I140, for_undef_118
-    iter $P138, $P139
-    new $P157, 'ExceptionHandler'
-    set_addr $P157, loop156_handler
-    $P157."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P157
-  loop156_test:
-    unless $P138, loop156_done
-    shift $P141, $P138
-  loop156_redo:
-    .const 'Sub' $P143 = "18_1278500533.96053" 
-    capture_lex $P143
-    $P143($P141)
-  loop156_next:
-    goto loop156_test
-  loop156_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P158, exception, 'type'
-    eq $P158, .CONTROL_LOOP_NEXT, loop156_next
-    eq $P158, .CONTROL_LOOP_REDO, loop156_redo
-  loop156_done:
+.sub "_block138"  :anon :subid("17_1279529222.65073") :outer("13_1279529222.65073")
+    .param pmc param_141
+.annotate 'line', 522
+    .const 'Sub' $P150 = "18_1279529222.65073" 
+    capture_lex $P150
+.annotate 'line', 523
+    $P140 = root_new ['parrot';'Hash']
+    .lex "%x", $P140
+    .lex "$_", param_141
+    find_lex $P142, "$_"
+    find_lex $P143, "$count"
+    $P144 = "capnames"($P142, $P143)
+    store_lex "%x", $P144
+.annotate 'line', 524
+    find_lex $P146, "%x"
+    defined $I147, $P146
+    unless $I147, for_undef_122
+    iter $P145, $P146
+    new $P164, 'ExceptionHandler'
+    set_addr $P164, loop163_handler
+    $P164."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P164
+  loop163_test:
+    unless $P145, loop163_done
+    shift $P148, $P145
+  loop163_redo:
+    .const 'Sub' $P150 = "18_1279529222.65073" 
+    capture_lex $P150
+    $P150($P148)
+  loop163_next:
+    goto loop163_test
+  loop163_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P165, exception, 'type'
+    eq $P165, .CONTROL_LOOP_NEXT, loop163_next
+    eq $P165, .CONTROL_LOOP_REDO, loop163_redo
+  loop163_done:
     pop_eh 
-  for_undef_118:
-.annotate 'line', 533
-    find_lex $P159, "%x"
-    unless_null $P159, vivify_124
-    $P159 = root_new ['parrot';'Hash']
-  vivify_124:
-    set $P160, $P159[""]
-    unless_null $P160, vivify_125
-    new $P160, "Undef"
-  vivify_125:
-    store_lex "$count", $P160
-.annotate 'line', 528
-    .return ($P160)
+  for_undef_122:
+.annotate 'line', 527
+    find_lex $P166, "%x"
+    unless_null $P166, vivify_128
+    $P166 = root_new ['parrot';'Hash']
+  vivify_128:
+    set $P167, $P166[""]
+    unless_null $P167, vivify_129
+    new $P167, "Undef"
+  vivify_129:
+    store_lex "$count", $P167
+.annotate 'line', 522
+    .return ($P167)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block142"  :anon :subid("18_1278500533.96053") :outer("17_1278500533.96053")
-    .param pmc param_144
-.annotate 'line', 530
-    .lex "$_", param_144
-.annotate 'line', 531
-    find_lex $P145, "$_"
-    find_lex $P146, "%capnames"
-    unless_null $P146, vivify_119
-    $P146 = root_new ['parrot';'Hash']
-  vivify_119:
-    set $P147, $P146[$P145]
-    unless_null $P147, vivify_120
-    new $P147, "Undef"
-  vivify_120:
-    set $N148, $P147
-    new $P149, 'Float'
-    set $P149, $N148
-    find_lex $P150, "$_"
-    find_lex $P151, "%x"
-    unless_null $P151, vivify_121
-    $P151 = root_new ['parrot';'Hash']
-  vivify_121:
-    set $P152, $P151[$P150]
-    unless_null $P152, vivify_122
-    new $P152, "Undef"
-  vivify_122:
-    add $P153, $P149, $P152
-    find_lex $P154, "$_"
-    find_lex $P155, "%capnames"
-    unless_null $P155, vivify_123
-    $P155 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P155
+.sub "_block149"  :anon :subid("18_1279529222.65073") :outer("17_1279529222.65073")
+    .param pmc param_151
+.annotate 'line', 524
+    .lex "$_", param_151
+.annotate 'line', 525
+    find_lex $P152, "$_"
+    find_lex $P153, "%capnames"
+    unless_null $P153, vivify_123
+    $P153 = root_new ['parrot';'Hash']
   vivify_123:
-    set $P155[$P154], $P153
-.annotate 'line', 530
-    .return ($P153)
+    set $P154, $P153[$P152]
+    unless_null $P154, vivify_124
+    new $P154, "Undef"
+  vivify_124:
+    set $N155, $P154
+    new $P156, 'Float'
+    set $P156, $N155
+    find_lex $P157, "$_"
+    find_lex $P158, "%x"
+    unless_null $P158, vivify_125
+    $P158 = root_new ['parrot';'Hash']
+  vivify_125:
+    set $P159, $P158[$P157]
+    unless_null $P159, vivify_126
+    new $P159, "Undef"
+  vivify_126:
+    add $P160, $P156, $P159
+    find_lex $P161, "$_"
+    find_lex $P162, "%capnames"
+    unless_null $P162, vivify_127
+    $P162 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P162
+  vivify_127:
+    set $P162[$P161], $P160
+.annotate 'line', 524
+    .return ($P160)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block64"  :anon :subid("14_1278500533.96053") :outer("13_1278500533.96053")
-.annotate 'line', 514
-    .const 'Sub' $P74 = "15_1278500533.96053" 
-    capture_lex $P74
-.annotate 'line', 515
-    new $P66, "Undef"
-    .lex "$max", $P66
-    find_lex $P67, "$count"
-    store_lex "$max", $P67
-.annotate 'line', 516
-    find_lex $P69, "$ast"
-    $P70 = $P69."list"()
-    defined $I71, $P70
-    unless $I71, for_undef_126
-    iter $P68, $P70
-    new $P119, 'ExceptionHandler'
-    set_addr $P119, loop118_handler
-    $P119."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P119
-  loop118_test:
-    unless $P68, loop118_done
-    shift $P72, $P68
-  loop118_redo:
-    .const 'Sub' $P74 = "15_1278500533.96053" 
-    capture_lex $P74
-    $P74($P72)
-  loop118_next:
-    goto loop118_test
-  loop118_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P120, exception, 'type'
-    eq $P120, .CONTROL_LOOP_NEXT, loop118_next
-    eq $P120, .CONTROL_LOOP_REDO, loop118_redo
-  loop118_done:
+.sub "_block71"  :anon :subid("14_1279529222.65073") :outer("13_1279529222.65073")
+.annotate 'line', 508
+    .const 'Sub' $P81 = "15_1279529222.65073" 
+    capture_lex $P81
+.annotate 'line', 509
+    new $P73, "Undef"
+    .lex "$max", $P73
+    find_lex $P74, "$count"
+    store_lex "$max", $P74
+.annotate 'line', 510
+    find_lex $P76, "$ast"
+    $P77 = $P76."list"()
+    defined $I78, $P77
+    unless $I78, for_undef_130
+    iter $P75, $P77
+    new $P126, 'ExceptionHandler'
+    set_addr $P126, loop125_handler
+    $P126."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P126
+  loop125_test:
+    unless $P75, loop125_done
+    shift $P79, $P75
+  loop125_redo:
+    .const 'Sub' $P81 = "15_1279529222.65073" 
+    capture_lex $P81
+    $P81($P79)
+  loop125_next:
+    goto loop125_test
+  loop125_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P127, exception, 'type'
+    eq $P127, .CONTROL_LOOP_NEXT, loop125_next
+    eq $P127, .CONTROL_LOOP_REDO, loop125_redo
+  loop125_done:
     pop_eh 
-  for_undef_126:
-.annotate 'line', 525
-    find_lex $P121, "$max"
-    store_lex "$count", $P121
-.annotate 'line', 514
-    .return ($P121)
+  for_undef_130:
+.annotate 'line', 519
+    find_lex $P128, "$max"
+    store_lex "$count", $P128
+.annotate 'line', 508
+    .return ($P128)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block73"  :anon :subid("15_1278500533.96053") :outer("14_1278500533.96053")
-    .param pmc param_76
-.annotate 'line', 516
-    .const 'Sub' $P85 = "16_1278500533.96053" 
-    capture_lex $P85
-.annotate 'line', 517
-    $P75 = root_new ['parrot';'Hash']
-    .lex "%x", $P75
-    .lex "$_", param_76
-    find_lex $P77, "$_"
-    find_lex $P78, "$count"
-    $P79 = "capnames"($P77, $P78)
-    store_lex "%x", $P79
-.annotate 'line', 518
-    find_lex $P81, "%x"
-    defined $I82, $P81
-    unless $I82, for_undef_127
-    iter $P80, $P81
-    new $P106, 'ExceptionHandler'
-    set_addr $P106, loop105_handler
-    $P106."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P106
-  loop105_test:
-    unless $P80, loop105_done
-    shift $P83, $P80
-  loop105_redo:
-    .const 'Sub' $P85 = "16_1278500533.96053" 
-    capture_lex $P85
-    $P85($P83)
-  loop105_next:
-    goto loop105_test
-  loop105_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P107, exception, 'type'
-    eq $P107, .CONTROL_LOOP_NEXT, loop105_next
-    eq $P107, .CONTROL_LOOP_REDO, loop105_redo
-  loop105_done:
+.sub "_block80"  :anon :subid("15_1279529222.65073") :outer("14_1279529222.65073")
+    .param pmc param_83
+.annotate 'line', 510
+    .const 'Sub' $P92 = "16_1279529222.65073" 
+    capture_lex $P92
+.annotate 'line', 511
+    $P82 = root_new ['parrot';'Hash']
+    .lex "%x", $P82
+    .lex "$_", param_83
+    find_lex $P84, "$_"
+    find_lex $P85, "$count"
+    $P86 = "capnames"($P84, $P85)
+    store_lex "%x", $P86
+.annotate 'line', 512
+    find_lex $P88, "%x"
+    defined $I89, $P88
+    unless $I89, for_undef_131
+    iter $P87, $P88
+    new $P113, 'ExceptionHandler'
+    set_addr $P113, loop112_handler
+    $P113."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P113
+  loop112_test:
+    unless $P87, loop112_done
+    shift $P90, $P87
+  loop112_redo:
+    .const 'Sub' $P92 = "16_1279529222.65073" 
+    capture_lex $P92
+    $P92($P90)
+  loop112_next:
+    goto loop112_test
+  loop112_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P114, exception, 'type'
+    eq $P114, .CONTROL_LOOP_NEXT, loop112_next
+    eq $P114, .CONTROL_LOOP_REDO, loop112_redo
+  loop112_done:
     pop_eh 
-  for_undef_127:
-.annotate 'line', 523
-    find_lex $P110, "%x"
-    unless_null $P110, vivify_133
-    $P110 = root_new ['parrot';'Hash']
-  vivify_133:
-    set $P111, $P110[""]
-    unless_null $P111, vivify_134
-    new $P111, "Undef"
-  vivify_134:
-    set $N112, $P111
-    find_lex $P113, "$max"
-    set $N114, $P113
-    isgt $I115, $N112, $N114
-    if $I115, if_109
-    new $P108, 'Integer'
-    set $P108, $I115
-    goto if_109_end
-  if_109:
-    find_lex $P116, "%x"
-    unless_null $P116, vivify_135
-    $P116 = root_new ['parrot';'Hash']
-  vivify_135:
-    set $P117, $P116[""]
-    unless_null $P117, vivify_136
-    new $P117, "Undef"
-  vivify_136:
-    store_lex "$max", $P117
-    set $P108, $P117
-  if_109_end:
-.annotate 'line', 516
-    .return ($P108)
+  for_undef_131:
+.annotate 'line', 517
+    find_lex $P117, "%x"
+    unless_null $P117, vivify_137
+    $P117 = root_new ['parrot';'Hash']
+  vivify_137:
+    set $P118, $P117[""]
+    unless_null $P118, vivify_138
+    new $P118, "Undef"
+  vivify_138:
+    set $N119, $P118
+    find_lex $P120, "$max"
+    set $N121, $P120
+    isgt $I122, $N119, $N121
+    if $I122, if_116
+    new $P115, 'Integer'
+    set $P115, $I122
+    goto if_116_end
+  if_116:
+    find_lex $P123, "%x"
+    unless_null $P123, vivify_139
+    $P123 = root_new ['parrot';'Hash']
+  vivify_139:
+    set $P124, $P123[""]
+    unless_null $P124, vivify_140
+    new $P124, "Undef"
+  vivify_140:
+    store_lex "$max", $P124
+    set $P115, $P124
+  if_116_end:
+.annotate 'line', 510
+    .return ($P115)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block84"  :anon :subid("16_1278500533.96053") :outer("15_1278500533.96053")
-    .param pmc param_86
-.annotate 'line', 518
-    .lex "$_", param_86
-.annotate 'line', 519
-    find_lex $P91, "$_"
-    find_lex $P92, "%capnames"
-    unless_null $P92, vivify_128
-    $P92 = root_new ['parrot';'Hash']
-  vivify_128:
-    set $P93, $P92[$P91]
-    unless_null $P93, vivify_129
-    new $P93, "Undef"
-  vivify_129:
-    set $N94, $P93
-    islt $I95, $N94, 2.0
-    if $I95, if_90
-    new $P89, 'Integer'
-    set $P89, $I95
-    goto if_90_end
-  if_90:
-    find_lex $P96, "$_"
-    find_lex $P97, "%x"
-    unless_null $P97, vivify_130
-    $P97 = root_new ['parrot';'Hash']
-  vivify_130:
-    set $P98, $P97[$P96]
-    unless_null $P98, vivify_131
-    new $P98, "Undef"
-  vivify_131:
-    set $N99, $P98
-    iseq $I100, $N99, 1.0
-    new $P89, 'Integer'
-    set $P89, $I100
-  if_90_end:
-    if $P89, if_88
-    new $P102, "Integer"
-    assign $P102, 2
-    set $P87, $P102
-    goto if_88_end
-  if_88:
-    new $P101, "Integer"
-    assign $P101, 1
-    set $P87, $P101
-  if_88_end:
-.annotate 'line', 520
+.sub "_block91"  :anon :subid("16_1279529222.65073") :outer("15_1279529222.65073")
+    .param pmc param_93
+.annotate 'line', 512
+    .lex "$_", param_93
+.annotate 'line', 513
+    find_lex $P98, "$_"
+    find_lex $P99, "%capnames"
+    unless_null $P99, vivify_132
+    $P99 = root_new ['parrot';'Hash']
+  vivify_132:
+    set $P100, $P99[$P98]
+    unless_null $P100, vivify_133
+    new $P100, "Undef"
+  vivify_133:
+    set $N101, $P100
+    islt $I102, $N101, 2.0
+    if $I102, if_97
+    new $P96, 'Integer'
+    set $P96, $I102
+    goto if_97_end
+  if_97:
     find_lex $P103, "$_"
-    find_lex $P104, "%capnames"
-    unless_null $P104, vivify_132
+    find_lex $P104, "%x"
+    unless_null $P104, vivify_134
     $P104 = root_new ['parrot';'Hash']
-    store_lex "%capnames", $P104
-  vivify_132:
-    set $P104[$P103], $P87
-.annotate 'line', 518
-    .return ($P87)
+  vivify_134:
+    set $P105, $P104[$P103]
+    unless_null $P105, vivify_135
+    new $P105, "Undef"
+  vivify_135:
+    set $N106, $P105
+    iseq $I107, $N106, 1.0
+    new $P96, 'Integer'
+    set $P96, $I107
+  if_97_end:
+    if $P96, if_95
+    new $P109, "Integer"
+    assign $P109, 2
+    set $P94, $P109
+    goto if_95_end
+  if_95:
+    new $P108, "Integer"
+    assign $P108, 1
+    set $P94, $P108
+  if_95_end:
+.annotate 'line', 514
+    find_lex $P110, "$_"
+    find_lex $P111, "%capnames"
+    unless_null $P111, vivify_136
+    $P111 = root_new ['parrot';'Hash']
+    store_lex "%capnames", $P111
+  vivify_136:
+    set $P111[$P110], $P94
+.annotate 'line', 512
+    .return ($P94)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backmod"  :subid("26_1278500533.96053") :outer("11_1278500533.96053")
-    .param pmc param_308
-    .param pmc param_309
-.annotate 'line', 577
-    new $P307, 'ExceptionHandler'
-    set_addr $P307, control_306
-    $P307."handle_types"(.CONTROL_RETURN)
-    push_eh $P307
-    .lex "$ast", param_308
-    .lex "$backmod", param_309
-.annotate 'line', 578
-    find_lex $P311, "$backmod"
-    set $S312, $P311
-    iseq $I313, $S312, ":"
-    if $I313, if_310
-.annotate 'line', 579
+.sub "backmod"  :subid("26_1279529222.65073") :outer("11_1279529222.65073")
+    .param pmc param_315
+    .param pmc param_316
+.annotate 'line', 571
+    new $P314, 'ExceptionHandler'
+    set_addr $P314, control_313
+    $P314."handle_types"(.CONTROL_RETURN)
+    push_eh $P314
+    .lex "$ast", param_315
+    .lex "$backmod", param_316
+.annotate 'line', 572
     find_lex $P318, "$backmod"
     set $S319, $P318
-    iseq $I320, $S319, ":?"
-    unless $I320, unless_317
-    new $P316, 'Integer'
-    set $P316, $I320
-    goto unless_317_end
-  unless_317:
-    find_lex $P321, "$backmod"
-    set $S322, $P321
-    iseq $I323, $S322, "?"
-    new $P316, 'Integer'
-    set $P316, $I323
-  unless_317_end:
-    if $P316, if_315
-.annotate 'line', 580
+    iseq $I320, $S319, ":"
+    if $I320, if_317
+.annotate 'line', 573
+    find_lex $P325, "$backmod"
+    set $S326, $P325
+    iseq $I327, $S326, ":?"
+    unless $I327, unless_324
+    new $P323, 'Integer'
+    set $P323, $I327
+    goto unless_324_end
+  unless_324:
     find_lex $P328, "$backmod"
     set $S329, $P328
-    iseq $I330, $S329, ":!"
-    unless $I330, unless_327
-    new $P326, 'Integer'
-    set $P326, $I330
-    goto unless_327_end
-  unless_327:
-    find_lex $P331, "$backmod"
-    set $S332, $P331
-    iseq $I333, $S332, "!"
-    new $P326, 'Integer'
-    set $P326, $I333
-  unless_327_end:
-    unless $P326, if_325_end
-    find_lex $P334, "$ast"
-    $P334."backtrack"("g")
-  if_325_end:
-    goto if_315_end
-  if_315:
-.annotate 'line', 579
-    find_lex $P324, "$ast"
-    $P324."backtrack"("f")
-  if_315_end:
-    goto if_310_end
-  if_310:
-.annotate 'line', 578
-    find_lex $P314, "$ast"
-    $P314."backtrack"("r")
-  if_310_end:
-    find_lex $P335, "$ast"
-.annotate 'line', 577
-    .return ($P335)
-  control_306:
+    iseq $I330, $S329, "?"
+    new $P323, 'Integer'
+    set $P323, $I330
+  unless_324_end:
+    if $P323, if_322
+.annotate 'line', 574
+    find_lex $P335, "$backmod"
+    set $S336, $P335
+    iseq $I337, $S336, ":!"
+    unless $I337, unless_334
+    new $P333, 'Integer'
+    set $P333, $I337
+    goto unless_334_end
+  unless_334:
+    find_lex $P338, "$backmod"
+    set $S339, $P338
+    iseq $I340, $S339, "!"
+    new $P333, 'Integer'
+    set $P333, $I340
+  unless_334_end:
+    unless $P333, if_332_end
+    find_lex $P341, "$ast"
+    $P341."backtrack"("g")
+  if_332_end:
+    goto if_322_end
+  if_322:
+.annotate 'line', 573
+    find_lex $P331, "$ast"
+    $P331."backtrack"("f")
+  if_322_end:
+    goto if_317_end
+  if_317:
+.annotate 'line', 572
+    find_lex $P321, "$ast"
+    $P321."backtrack"("r")
+  if_317_end:
+    find_lex $P342, "$ast"
+.annotate 'line', 571
+    .return ($P342)
+  control_313:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P336, exception, "payload"
-    .return ($P336)
+    getattribute $P343, exception, "payload"
+    .return ($P343)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "arg"  :subid("27_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_342
+.sub "arg"  :subid("27_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_349
 .annotate 'line', 14
-    new $P341, 'ExceptionHandler'
-    set_addr $P341, control_340
-    $P341."handle_types"(.CONTROL_RETURN)
-    push_eh $P341
+    new $P348, 'ExceptionHandler'
+    set_addr $P348, control_347
+    $P348."handle_types"(.CONTROL_RETURN)
+    push_eh $P348
     .lex "self", self
-    .lex "$/", param_342
+    .lex "$/", param_349
 .annotate 'line', 15
-    find_lex $P343, "$/"
-    find_lex $P346, "$/"
-    unless_null $P346, vivify_138
-    $P346 = root_new ['parrot';'Hash']
-  vivify_138:
-    set $P347, $P346["quote_EXPR"]
-    unless_null $P347, vivify_139
-    new $P347, "Undef"
-  vivify_139:
-    if $P347, if_345
-    find_lex $P351, "$/"
-    unless_null $P351, vivify_140
-    $P351 = root_new ['parrot';'Hash']
-  vivify_140:
-    set $P352, $P351["val"]
-    unless_null $P352, vivify_141
-    new $P352, "Undef"
-  vivify_141:
-    set $N353, $P352
-    new $P344, 'Float'
-    set $P344, $N353
-    goto if_345_end
-  if_345:
-    find_lex $P348, "$/"
-    unless_null $P348, vivify_142
-    $P348 = root_new ['parrot';'Hash']
+    find_lex $P350, "$/"
+    find_lex $P353, "$/"
+    unless_null $P353, vivify_142
+    $P353 = root_new ['parrot';'Hash']
   vivify_142:
-    set $P349, $P348["quote_EXPR"]
-    unless_null $P349, vivify_143
-    new $P349, "Undef"
+    set $P354, $P353["quote_EXPR"]
+    unless_null $P354, vivify_143
+    new $P354, "Undef"
   vivify_143:
-    $P350 = $P349."ast"()
-    set $P344, $P350
-  if_345_end:
-    $P354 = $P343."!make"($P344)
+    if $P354, if_352
+    find_lex $P358, "$/"
+    unless_null $P358, vivify_144
+    $P358 = root_new ['parrot';'Hash']
+  vivify_144:
+    set $P359, $P358["val"]
+    unless_null $P359, vivify_145
+    new $P359, "Undef"
+  vivify_145:
+    set $N360, $P359
+    new $P351, 'Float'
+    set $P351, $N360
+    goto if_352_end
+  if_352:
+    find_lex $P355, "$/"
+    unless_null $P355, vivify_146
+    $P355 = root_new ['parrot';'Hash']
+  vivify_146:
+    set $P356, $P355["quote_EXPR"]
+    unless_null $P356, vivify_147
+    new $P356, "Undef"
+  vivify_147:
+    $P357 = $P356."ast"()
+    set $P351, $P357
+  if_352_end:
+    $P361 = $P350."!make"($P351)
 .annotate 'line', 14
-    .return ($P354)
-  control_340:
+    .return ($P361)
+  control_347:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P355, exception, "payload"
-    .return ($P355)
+    getattribute $P362, exception, "payload"
+    .return ($P362)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "arglist"  :subid("28_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_359
+.sub "arglist"  :subid("28_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_366
 .annotate 'line', 18
-    .const 'Sub' $P369 = "29_1278500533.96053" 
-    capture_lex $P369
-    new $P358, 'ExceptionHandler'
-    set_addr $P358, control_357
-    $P358."handle_types"(.CONTROL_RETURN)
-    push_eh $P358
+    .const 'Sub' $P376 = "29_1279529222.65073" 
+    capture_lex $P376
+    new $P365, 'ExceptionHandler'
+    set_addr $P365, control_364
+    $P365."handle_types"(.CONTROL_RETURN)
+    push_eh $P365
     .lex "self", self
-    .lex "$/", param_359
+    .lex "$/", param_366
 .annotate 'line', 19
-    new $P360, "Undef"
-    .lex "$past", $P360
-    get_hll_global $P361, ["PAST"], "Op"
-    $P362 = $P361."new"("list" :named("pasttype"))
-    store_lex "$past", $P362
+    new $P367, "Undef"
+    .lex "$past", $P367
+    get_hll_global $P368, ["PAST"], "Op"
+    $P369 = $P368."new"("list" :named("pasttype"))
+    store_lex "$past", $P369
 .annotate 'line', 20
-    find_lex $P364, "$/"
-    unless_null $P364, vivify_144
-    $P364 = root_new ['parrot';'Hash']
-  vivify_144:
-    set $P365, $P364["arg"]
-    unless_null $P365, vivify_145
-    new $P365, "Undef"
-  vivify_145:
-    defined $I366, $P365
-    unless $I366, for_undef_146
-    iter $P363, $P365
-    new $P376, 'ExceptionHandler'
-    set_addr $P376, loop375_handler
-    $P376."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P376
-  loop375_test:
-    unless $P363, loop375_done
-    shift $P367, $P363
-  loop375_redo:
-    .const 'Sub' $P369 = "29_1278500533.96053" 
-    capture_lex $P369
-    $P369($P367)
-  loop375_next:
-    goto loop375_test
-  loop375_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P377, exception, 'type'
-    eq $P377, .CONTROL_LOOP_NEXT, loop375_next
-    eq $P377, .CONTROL_LOOP_REDO, loop375_redo
-  loop375_done:
+    find_lex $P371, "$/"
+    unless_null $P371, vivify_148
+    $P371 = root_new ['parrot';'Hash']
+  vivify_148:
+    set $P372, $P371["arg"]
+    unless_null $P372, vivify_149
+    new $P372, "Undef"
+  vivify_149:
+    defined $I373, $P372
+    unless $I373, for_undef_150
+    iter $P370, $P372
+    new $P383, 'ExceptionHandler'
+    set_addr $P383, loop382_handler
+    $P383."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P383
+  loop382_test:
+    unless $P370, loop382_done
+    shift $P374, $P370
+  loop382_redo:
+    .const 'Sub' $P376 = "29_1279529222.65073" 
+    capture_lex $P376
+    $P376($P374)
+  loop382_next:
+    goto loop382_test
+  loop382_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P384, exception, 'type'
+    eq $P384, .CONTROL_LOOP_NEXT, loop382_next
+    eq $P384, .CONTROL_LOOP_REDO, loop382_redo
+  loop382_done:
     pop_eh 
-  for_undef_146:
+  for_undef_150:
 .annotate 'line', 21
-    find_lex $P378, "$/"
-    find_lex $P379, "$past"
-    $P380 = $P378."!make"($P379)
+    find_lex $P385, "$/"
+    find_lex $P386, "$past"
+    $P387 = $P385."!make"($P386)
 .annotate 'line', 18
-    .return ($P380)
-  control_357:
+    .return ($P387)
+  control_364:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P381, exception, "payload"
-    .return ($P381)
+    getattribute $P388, exception, "payload"
+    .return ($P388)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block368"  :anon :subid("29_1278500533.96053") :outer("28_1278500533.96053")
-    .param pmc param_370
+.sub "_block375"  :anon :subid("29_1279529222.65073") :outer("28_1279529222.65073")
+    .param pmc param_377
 .annotate 'line', 20
-    .lex "$_", param_370
-    find_lex $P371, "$past"
-    find_lex $P372, "$_"
-    $P373 = $P372."ast"()
-    $P374 = $P371."push"($P373)
-    .return ($P374)
+    .lex "$_", param_377
+    find_lex $P378, "$past"
+    find_lex $P379, "$_"
+    $P380 = $P379."ast"()
+    $P381 = $P378."push"($P380)
+    .return ($P381)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "TOP"  :subid("30_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_385
+.sub "TOP"  :subid("30_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_392
 .annotate 'line', 24
-    new $P384, 'ExceptionHandler'
-    set_addr $P384, control_383
-    $P384."handle_types"(.CONTROL_RETURN)
-    push_eh $P384
+    new $P391, 'ExceptionHandler'
+    set_addr $P391, control_390
+    $P391."handle_types"(.CONTROL_RETURN)
+    push_eh $P391
     .lex "self", self
-    .lex "$/", param_385
+    .lex "$/", param_392
 .annotate 'line', 25
-    new $P386, "Undef"
-    .lex "$past", $P386
-    find_lex $P387, "$/"
-    unless_null $P387, vivify_147
-    $P387 = root_new ['parrot';'Hash']
-  vivify_147:
-    set $P388, $P387["nibbler"]
-    unless_null $P388, vivify_148
-    new $P388, "Undef"
-  vivify_148:
-    $P389 = $P388."ast"()
-    $P390 = "buildsub"($P389)
-    store_lex "$past", $P390
+    new $P393, "Undef"
+    .lex "$past", $P393
+    find_lex $P394, "$/"
+    unless_null $P394, vivify_151
+    $P394 = root_new ['parrot';'Hash']
+  vivify_151:
+    set $P395, $P394["nibbler"]
+    unless_null $P395, vivify_152
+    new $P395, "Undef"
+  vivify_152:
+    $P396 = $P395."ast"()
+    $P397 = "buildsub"($P396)
+    store_lex "$past", $P397
 .annotate 'line', 26
-    find_lex $P391, "$past"
-    find_lex $P392, "$/"
-    $P391."node"($P392)
+    find_lex $P398, "$past"
+    find_lex $P399, "$/"
+    $P398."node"($P399)
 .annotate 'line', 27
-    find_lex $P393, "$/"
-    find_lex $P394, "$past"
-    $P395 = $P393."!make"($P394)
+    find_lex $P400, "$/"
+    find_lex $P401, "$past"
+    $P402 = $P400."!make"($P401)
 .annotate 'line', 24
-    .return ($P395)
-  control_383:
+    .return ($P402)
+  control_390:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P396, exception, "payload"
-    .return ($P396)
+    getattribute $P403, exception, "payload"
+    .return ($P403)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "nibbler"  :subid("31_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_400
-    .param pmc param_401 :optional
-    .param int has_param_401 :opt_flag
+.sub "nibbler"  :subid("31_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_407
+    .param pmc param_408 :optional
+    .param int has_param_408 :opt_flag
 .annotate 'line', 30
-    .const 'Sub' $P435 = "33_1278500533.96053" 
-    capture_lex $P435
-    .const 'Sub' $P409 = "32_1278500533.96053" 
-    capture_lex $P409
-    new $P399, 'ExceptionHandler'
-    set_addr $P399, control_398
-    $P399."handle_types"(.CONTROL_RETURN)
-    push_eh $P399
-    .lex "self", self
-    .lex "$/", param_400
-    if has_param_401, optparam_149
-    new $P402, "Undef"
-    set param_401, $P402
-  optparam_149:
-    .lex "$key", param_401
+    .const 'Sub' $P442 = "33_1279529222.65073" 
+    capture_lex $P442
+    .const 'Sub' $P416 = "32_1279529222.65073" 
+    capture_lex $P416
+    new $P406, 'ExceptionHandler'
+    set_addr $P406, control_405
+    $P406."handle_types"(.CONTROL_RETURN)
+    push_eh $P406
+    .lex "self", self
+    .lex "$/", param_407
+    if has_param_408, optparam_153
+    new $P409, "Undef"
+    set param_408, $P409
+  optparam_153:
+    .lex "$key", param_408
 .annotate 'line', 42
-    new $P403, "Undef"
-    .lex "$past", $P403
+    new $P410, "Undef"
+    .lex "$past", $P410
 .annotate 'line', 31
-    find_lex $P405, "$key"
-    set $S406, $P405
-    iseq $I407, $S406, "open"
-    unless $I407, if_404_end
-    .const 'Sub' $P409 = "32_1278500533.96053" 
-    capture_lex $P409
-    $P409()
-  if_404_end:
+    find_lex $P412, "$key"
+    set $S413, $P412
+    iseq $I414, $S413, "open"
+    unless $I414, if_411_end
+    .const 'Sub' $P416 = "32_1279529222.65073" 
+    capture_lex $P416
+    $P416()
+  if_411_end:
 .annotate 'line', 41
-    get_global $P419, "@MODIFIERS"
-    $P419."shift"()
-    find_lex $P420, "$past"
+    get_global $P426, "@MODIFIERS"
+    $P426."shift"()
+    find_lex $P427, "$past"
 .annotate 'line', 43
-    find_lex $P422, "$/"
-    unless_null $P422, vivify_152
-    $P422 = root_new ['parrot';'Hash']
-  vivify_152:
-    set $P423, $P422["termish"]
-    unless_null $P423, vivify_153
-    new $P423, "Undef"
-  vivify_153:
-    set $N424, $P423
-    isgt $I425, $N424, 1.0
-    if $I425, if_421
-.annotate 'line', 50
-    find_lex $P444, "$/"
-    unless_null $P444, vivify_154
-    $P444 = root_new ['parrot';'Hash']
-  vivify_154:
-    set $P445, $P444["termish"]
-    unless_null $P445, vivify_155
-    $P445 = root_new ['parrot';'ResizablePMCArray']
-  vivify_155:
-    set $P446, $P445[0]
-    unless_null $P446, vivify_156
-    new $P446, "Undef"
+    find_lex $P429, "$/"
+    unless_null $P429, vivify_156
+    $P429 = root_new ['parrot';'Hash']
   vivify_156:
-    $P447 = $P446."ast"()
-    store_lex "$past", $P447
-.annotate 'line', 49
-    goto if_421_end
-  if_421:
-.annotate 'line', 44
-    get_hll_global $P426, ["PAST"], "Regex"
-    find_lex $P427, "$/"
-    $P428 = $P426."new"("alt" :named("pasttype"), $P427 :named("node"))
-    store_lex "$past", $P428
-.annotate 'line', 45
-    find_lex $P430, "$/"
+    set $P430, $P429["termish"]
     unless_null $P430, vivify_157
-    $P430 = root_new ['parrot';'Hash']
+    new $P430, "Undef"
   vivify_157:
-    set $P431, $P430["termish"]
-    unless_null $P431, vivify_158
-    new $P431, "Undef"
+    set $N431, $P430
+    isgt $I432, $N431, 1.0
+    if $I432, if_428
+.annotate 'line', 50
+    find_lex $P451, "$/"
+    unless_null $P451, vivify_158
+    $P451 = root_new ['parrot';'Hash']
   vivify_158:
-    defined $I432, $P431
-    unless $I432, for_undef_159
-    iter $P429, $P431
-    new $P442, 'ExceptionHandler'
-    set_addr $P442, loop441_handler
-    $P442."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P442
-  loop441_test:
-    unless $P429, loop441_done
-    shift $P433, $P429
-  loop441_redo:
-    .const 'Sub' $P435 = "33_1278500533.96053" 
-    capture_lex $P435
-    $P435($P433)
-  loop441_next:
-    goto loop441_test
-  loop441_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P443, exception, 'type'
-    eq $P443, .CONTROL_LOOP_NEXT, loop441_next
-    eq $P443, .CONTROL_LOOP_REDO, loop441_redo
-  loop441_done:
+    set $P452, $P451["termish"]
+    unless_null $P452, vivify_159
+    $P452 = root_new ['parrot';'ResizablePMCArray']
+  vivify_159:
+    set $P453, $P452[0]
+    unless_null $P453, vivify_160
+    new $P453, "Undef"
+  vivify_160:
+    $P454 = $P453."ast"()
+    store_lex "$past", $P454
+.annotate 'line', 49
+    goto if_428_end
+  if_428:
+.annotate 'line', 44
+    get_hll_global $P433, ["PAST"], "Regex"
+    find_lex $P434, "$/"
+    $P435 = $P433."new"("alt" :named("pasttype"), $P434 :named("node"))
+    store_lex "$past", $P435
+.annotate 'line', 45
+    find_lex $P437, "$/"
+    unless_null $P437, vivify_161
+    $P437 = root_new ['parrot';'Hash']
+  vivify_161:
+    set $P438, $P437["termish"]
+    unless_null $P438, vivify_162
+    new $P438, "Undef"
+  vivify_162:
+    defined $I439, $P438
+    unless $I439, for_undef_163
+    iter $P436, $P438
+    new $P449, 'ExceptionHandler'
+    set_addr $P449, loop448_handler
+    $P449."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P449
+  loop448_test:
+    unless $P436, loop448_done
+    shift $P440, $P436
+  loop448_redo:
+    .const 'Sub' $P442 = "33_1279529222.65073" 
+    capture_lex $P442
+    $P442($P440)
+  loop448_next:
+    goto loop448_test
+  loop448_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P450, exception, 'type'
+    eq $P450, .CONTROL_LOOP_NEXT, loop448_next
+    eq $P450, .CONTROL_LOOP_REDO, loop448_redo
+  loop448_done:
     pop_eh 
-  for_undef_159:
-  if_421_end:
+  for_undef_163:
+  if_428_end:
 .annotate 'line', 52
-    find_lex $P448, "$/"
-    find_lex $P449, "$past"
-    $P450 = $P448."!make"($P449)
+    find_lex $P455, "$/"
+    find_lex $P456, "$past"
+    $P457 = $P455."!make"($P456)
 .annotate 'line', 30
-    .return ($P450)
-  control_398:
+    .return ($P457)
+  control_405:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P451, exception, "payload"
-    .return ($P451)
+    getattribute $P458, exception, "payload"
+    .return ($P458)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "_block408"  :anon :subid("32_1278500533.96053") :outer("31_1278500533.96053")
+.sub "_block415"  :anon :subid("32_1279529222.65073") :outer("31_1279529222.65073")
 .annotate 'line', 32
-    $P410 = root_new ['parrot';'Hash']
-    .lex "%old", $P410
+    $P417 = root_new ['parrot';'Hash']
+    .lex "%old", $P417
 .annotate 'line', 33
-    $P411 = root_new ['parrot';'Hash']
-    .lex "%new", $P411
+    $P418 = root_new ['parrot';'Hash']
+    .lex "%new", $P418
 .annotate 'line', 32
-    get_global $P412, "@MODIFIERS"
-    unless_null $P412, vivify_150
-    $P412 = root_new ['parrot';'ResizablePMCArray']
-  vivify_150:
-    set $P413, $P412[0]
-    unless_null $P413, vivify_151
-    new $P413, "Undef"
-  vivify_151:
-    store_lex "%old", $P413
+    get_global $P419, "@MODIFIERS"
+    unless_null $P419, vivify_154
+    $P419 = root_new ['parrot';'ResizablePMCArray']
+  vivify_154:
+    set $P420, $P419[0]
+    unless_null $P420, vivify_155
+    new $P420, "Undef"
+  vivify_155:
+    store_lex "%old", $P420
 .annotate 'line', 33
 
                        $P0 = find_lex '%old'
-                       $P414 = clone $P0
+                       $P421 = clone $P0
                    
-    store_lex "%new", $P414
+    store_lex "%new", $P421
 .annotate 'line', 37
-    get_global $P415, "@MODIFIERS"
-    find_lex $P416, "%new"
-    $P415."unshift"($P416)
+    get_global $P422, "@MODIFIERS"
+    find_lex $P423, "%new"
+    $P422."unshift"($P423)
 .annotate 'line', 38
-    new $P417, "Exception"
-    set $P417['type'], .CONTROL_RETURN
-    new $P418, "Integer"
-    assign $P418, 1
-    setattribute $P417, 'payload', $P418
-    throw $P417
+    new $P424, "Exception"
+    set $P424['type'], .CONTROL_RETURN
+    new $P425, "Integer"
+    assign $P425, 1
+    setattribute $P424, 'payload', $P425
+    throw $P424
 .annotate 'line', 31
     .return ()
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block434"  :anon :subid("33_1278500533.96053") :outer("31_1278500533.96053")
-    .param pmc param_436
+.sub "_block441"  :anon :subid("33_1279529222.65073") :outer("31_1279529222.65073")
+    .param pmc param_443
 .annotate 'line', 45
-    .lex "$_", param_436
+    .lex "$_", param_443
 .annotate 'line', 46
-    find_lex $P437, "$past"
-    find_lex $P438, "$_"
-    $P439 = $P438."ast"()
-    $P440 = $P437."push"($P439)
+    find_lex $P444, "$past"
+    find_lex $P445, "$_"
+    $P446 = $P445."ast"()
+    $P447 = $P444."push"($P446)
 .annotate 'line', 45
-    .return ($P440)
+    .return ($P447)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "termish"  :subid("34_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_455
+.sub "termish"  :subid("34_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_462
 .annotate 'line', 55
-    .const 'Sub' $P468 = "35_1278500533.96053" 
-    capture_lex $P468
-    new $P454, 'ExceptionHandler'
-    set_addr $P454, control_453
-    $P454."handle_types"(.CONTROL_RETURN)
-    push_eh $P454
+    .const 'Sub' $P475 = "35_1279529222.65073" 
+    capture_lex $P475
+    new $P461, 'ExceptionHandler'
+    set_addr $P461, control_460
+    $P461."handle_types"(.CONTROL_RETURN)
+    push_eh $P461
     .lex "self", self
-    .lex "$/", param_455
+    .lex "$/", param_462
 .annotate 'line', 56
-    new $P456, "Undef"
-    .lex "$past", $P456
+    new $P463, "Undef"
+    .lex "$past", $P463
 .annotate 'line', 57
-    new $P457, "Undef"
-    .lex "$lastlit", $P457
+    new $P464, "Undef"
+    .lex "$lastlit", $P464
 .annotate 'line', 56
-    get_hll_global $P458, ["PAST"], "Regex"
-    find_lex $P459, "$/"
-    $P460 = $P458."new"("concat" :named("pasttype"), $P459 :named("node"))
-    store_lex "$past", $P460
+    get_hll_global $P465, ["PAST"], "Regex"
+    find_lex $P466, "$/"
+    $P467 = $P465."new"("concat" :named("pasttype"), $P466 :named("node"))
+    store_lex "$past", $P467
 .annotate 'line', 57
-    new $P461, "Integer"
-    assign $P461, 0
-    store_lex "$lastlit", $P461
+    new $P468, "Integer"
+    assign $P468, 0
+    store_lex "$lastlit", $P468
 .annotate 'line', 58
-    find_lex $P463, "$/"
-    unless_null $P463, vivify_160
-    $P463 = root_new ['parrot';'Hash']
-  vivify_160:
-    set $P464, $P463["noun"]
-    unless_null $P464, vivify_161
-    new $P464, "Undef"
-  vivify_161:
-    defined $I465, $P464
-    unless $I465, for_undef_162
-    iter $P462, $P464
-    new $P514, 'ExceptionHandler'
-    set_addr $P514, loop513_handler
-    $P514."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P514
-  loop513_test:
-    unless $P462, loop513_done
-    shift $P466, $P462
-  loop513_redo:
-    .const 'Sub' $P468 = "35_1278500533.96053" 
-    capture_lex $P468
-    $P468($P466)
-  loop513_next:
-    goto loop513_test
-  loop513_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P515, exception, 'type'
-    eq $P515, .CONTROL_LOOP_NEXT, loop513_next
-    eq $P515, .CONTROL_LOOP_REDO, loop513_redo
-  loop513_done:
+    find_lex $P470, "$/"
+    unless_null $P470, vivify_164
+    $P470 = root_new ['parrot';'Hash']
+  vivify_164:
+    set $P471, $P470["noun"]
+    unless_null $P471, vivify_165
+    new $P471, "Undef"
+  vivify_165:
+    defined $I472, $P471
+    unless $I472, for_undef_166
+    iter $P469, $P471
+    new $P521, 'ExceptionHandler'
+    set_addr $P521, loop520_handler
+    $P521."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P521
+  loop520_test:
+    unless $P469, loop520_done
+    shift $P473, $P469
+  loop520_redo:
+    .const 'Sub' $P475 = "35_1279529222.65073" 
+    capture_lex $P475
+    $P475($P473)
+  loop520_next:
+    goto loop520_test
+  loop520_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P522, exception, 'type'
+    eq $P522, .CONTROL_LOOP_NEXT, loop520_next
+    eq $P522, .CONTROL_LOOP_REDO, loop520_redo
+  loop520_done:
     pop_eh 
-  for_undef_162:
+  for_undef_166:
 .annotate 'line', 73
-    find_lex $P516, "$/"
-    find_lex $P517, "$past"
-    $P518 = $P516."!make"($P517)
+    find_lex $P523, "$/"
+    find_lex $P524, "$past"
+    $P525 = $P523."!make"($P524)
 .annotate 'line', 55
-    .return ($P518)
-  control_453:
+    .return ($P525)
+  control_460:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P519, exception, "payload"
-    .return ($P519)
+    getattribute $P526, exception, "payload"
+    .return ($P526)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block467"  :anon :subid("35_1278500533.96053") :outer("34_1278500533.96053")
-    .param pmc param_470
+.sub "_block474"  :anon :subid("35_1279529222.65073") :outer("34_1279529222.65073")
+    .param pmc param_477
 .annotate 'line', 59
-    new $P469, "Undef"
-    .lex "$ast", $P469
-    .lex "$_", param_470
-    find_lex $P471, "$_"
-    $P472 = $P471."ast"()
-    store_lex "$ast", $P472
+    new $P476, "Undef"
+    .lex "$ast", $P476
+    .lex "$_", param_477
+    find_lex $P478, "$_"
+    $P479 = $P478."ast"()
+    store_lex "$ast", $P479
 .annotate 'line', 60
-    find_lex $P475, "$ast"
-    if $P475, if_474
-    set $P473, $P475
-    goto if_474_end
-  if_474:
-.annotate 'line', 61
-    find_lex $P482, "$lastlit"
+    find_lex $P482, "$ast"
     if $P482, if_481
     set $P480, $P482
     goto if_481_end
   if_481:
-    find_lex $P483, "$ast"
-    $S484 = $P483."pasttype"()
-    iseq $I485, $S484, "literal"
-    new $P480, 'Integer'
-    set $P480, $I485
-  if_481_end:
-    if $P480, if_479
-    set $P478, $P480
-    goto if_479_end
-  if_479:
+.annotate 'line', 61
+    find_lex $P489, "$lastlit"
+    if $P489, if_488
+    set $P487, $P489
+    goto if_488_end
+  if_488:
+    find_lex $P490, "$ast"
+    $S491 = $P490."pasttype"()
+    iseq $I492, $S491, "literal"
+    new $P487, 'Integer'
+    set $P487, $I492
+  if_488_end:
+    if $P487, if_486
+    set $P485, $P487
+    goto if_486_end
+  if_486:
 .annotate 'line', 62
-    get_hll_global $P486, ["PAST"], "Node"
-    find_lex $P487, "$ast"
-    unless_null $P487, vivify_163
-    $P487 = root_new ['parrot';'ResizablePMCArray']
-  vivify_163:
-    set $P488, $P487[0]
-    unless_null $P488, vivify_164
-    new $P488, "Undef"
-  vivify_164:
-    $P489 = $P486."ACCEPTS"($P488)
-    isfalse $I490, $P489
-    new $P478, 'Integer'
-    set $P478, $I490
-  if_479_end:
-    if $P478, if_477
+    get_hll_global $P493, ["PAST"], "Node"
+    find_lex $P494, "$ast"
+    unless_null $P494, vivify_167
+    $P494 = root_new ['parrot';'ResizablePMCArray']
+  vivify_167:
+    set $P495, $P494[0]
+    unless_null $P495, vivify_168
+    new $P495, "Undef"
+  vivify_168:
+    $P496 = $P493."ACCEPTS"($P495)
+    isfalse $I497, $P496
+    new $P485, 'Integer'
+    set $P485, $I497
+  if_486_end:
+    if $P485, if_484
 .annotate 'line', 66
-    find_lex $P497, "$past"
-    find_lex $P498, "$ast"
-    $P497."push"($P498)
+    find_lex $P504, "$past"
+    find_lex $P505, "$ast"
+    $P504."push"($P505)
 .annotate 'line', 67
-    find_lex $P503, "$ast"
-    $S504 = $P503."pasttype"()
-    iseq $I505, $S504, "literal"
-    if $I505, if_502
-    new $P501, 'Integer'
-    set $P501, $I505
-    goto if_502_end
-  if_502:
+    find_lex $P510, "$ast"
+    $S511 = $P510."pasttype"()
+    iseq $I512, $S511, "literal"
+    if $I512, if_509
+    new $P508, 'Integer'
+    set $P508, $I512
+    goto if_509_end
+  if_509:
 .annotate 'line', 68
-    get_hll_global $P506, ["PAST"], "Node"
-    find_lex $P507, "$ast"
-    unless_null $P507, vivify_165
-    $P507 = root_new ['parrot';'ResizablePMCArray']
-  vivify_165:
-    set $P508, $P507[0]
-    unless_null $P508, vivify_166
-    new $P508, "Undef"
-  vivify_166:
-    $P509 = $P506."ACCEPTS"($P508)
-    isfalse $I510, $P509
-    new $P501, 'Integer'
-    set $P501, $I510
-  if_502_end:
-    if $P501, if_500
-    new $P512, "Integer"
-    assign $P512, 0
-    set $P499, $P512
-    goto if_500_end
-  if_500:
-    find_lex $P511, "$ast"
-    set $P499, $P511
-  if_500_end:
+    get_hll_global $P513, ["PAST"], "Node"
+    find_lex $P514, "$ast"
+    unless_null $P514, vivify_169
+    $P514 = root_new ['parrot';'ResizablePMCArray']
+  vivify_169:
+    set $P515, $P514[0]
+    unless_null $P515, vivify_170
+    new $P515, "Undef"
+  vivify_170:
+    $P516 = $P513."ACCEPTS"($P515)
+    isfalse $I517, $P516
+    new $P508, 'Integer'
+    set $P508, $I517
+  if_509_end:
+    if $P508, if_507
+    new $P519, "Integer"
+    assign $P519, 0
+    set $P506, $P519
+    goto if_507_end
+  if_507:
+    find_lex $P518, "$ast"
+    set $P506, $P518
+  if_507_end:
 .annotate 'line', 69
-    store_lex "$lastlit", $P499
+    store_lex "$lastlit", $P506
 .annotate 'line', 65
-    set $P476, $P499
+    set $P483, $P506
 .annotate 'line', 62
-    goto if_477_end
-  if_477:
+    goto if_484_end
+  if_484:
 .annotate 'line', 63
-    find_lex $P491, "$lastlit"
-    unless_null $P491, vivify_167
-    $P491 = root_new ['parrot';'ResizablePMCArray']
-  vivify_167:
-    set $P492, $P491[0]
-    unless_null $P492, vivify_168
-    new $P492, "Undef"
-  vivify_168:
-    find_lex $P493, "$ast"
-    unless_null $P493, vivify_169
-    $P493 = root_new ['parrot';'ResizablePMCArray']
-  vivify_169:
-    set $P494, $P493[0]
-    unless_null $P494, vivify_170
-    new $P494, "Undef"
-  vivify_170:
-    concat $P495, $P492, $P494
-    find_lex $P496, "$lastlit"
-    unless_null $P496, vivify_171
-    $P496 = root_new ['parrot';'ResizablePMCArray']
-    store_lex "$lastlit", $P496
+    find_lex $P498, "$lastlit"
+    unless_null $P498, vivify_171
+    $P498 = root_new ['parrot';'ResizablePMCArray']
   vivify_171:
-    set $P496[0], $P495
+    set $P499, $P498[0]
+    unless_null $P499, vivify_172
+    new $P499, "Undef"
+  vivify_172:
+    find_lex $P500, "$ast"
+    unless_null $P500, vivify_173
+    $P500 = root_new ['parrot';'ResizablePMCArray']
+  vivify_173:
+    set $P501, $P500[0]
+    unless_null $P501, vivify_174
+    new $P501, "Undef"
+  vivify_174:
+    concat $P502, $P499, $P501
+    find_lex $P503, "$lastlit"
+    unless_null $P503, vivify_175
+    $P503 = root_new ['parrot';'ResizablePMCArray']
+    store_lex "$lastlit", $P503
+  vivify_175:
+    set $P503[0], $P502
 .annotate 'line', 62
-    set $P476, $P495
-  if_477_end:
+    set $P483, $P502
+  if_484_end:
 .annotate 'line', 60
-    set $P473, $P476
-  if_474_end:
+    set $P480, $P483
+  if_481_end:
 .annotate 'line', 58
-    .return ($P473)
+    .return ($P480)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "quantified_atom"  :subid("36_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_523
+.sub "quantified_atom"  :subid("36_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_530
 .annotate 'line', 76
-    .const 'Sub' $P532 = "37_1278500533.96053" 
-    capture_lex $P532
-    new $P522, 'ExceptionHandler'
-    set_addr $P522, control_521
-    $P522."handle_types"(.CONTROL_RETURN)
-    push_eh $P522
+    .const 'Sub' $P539 = "37_1279529222.65073" 
+    capture_lex $P539
+    new $P529, 'ExceptionHandler'
+    set_addr $P529, control_528
+    $P529."handle_types"(.CONTROL_RETURN)
+    push_eh $P529
     .lex "self", self
-    .lex "$/", param_523
+    .lex "$/", param_530
 .annotate 'line', 77
-    new $P524, "Undef"
-    .lex "$past", $P524
-    find_lex $P525, "$/"
-    unless_null $P525, vivify_172
-    $P525 = root_new ['parrot';'Hash']
-  vivify_172:
-    set $P526, $P525["atom"]
-    unless_null $P526, vivify_173
-    new $P526, "Undef"
-  vivify_173:
-    $P527 = $P526."ast"()
-    store_lex "$past", $P527
-.annotate 'line', 78
-    find_lex $P529, "$/"
-    unless_null $P529, vivify_174
-    $P529 = root_new ['parrot';'Hash']
-  vivify_174:
-    set $P530, $P529["quantifier"]
-    unless_null $P530, vivify_175
-    new $P530, "Undef"
-  vivify_175:
-    if $P530, if_528
-.annotate 'line', 84
-    find_lex $P547, "$/"
-    unless_null $P547, vivify_176
-    $P547 = root_new ['parrot';'Hash']
+    new $P531, "Undef"
+    .lex "$past", $P531
+    find_lex $P532, "$/"
+    unless_null $P532, vivify_176
+    $P532 = root_new ['parrot';'Hash']
   vivify_176:
-    set $P548, $P547["backmod"]
-    unless_null $P548, vivify_177
-    $P548 = root_new ['parrot';'ResizablePMCArray']
+    set $P533, $P532["atom"]
+    unless_null $P533, vivify_177
+    new $P533, "Undef"
   vivify_177:
-    set $P549, $P548[0]
-    unless_null $P549, vivify_178
-    new $P549, "Undef"
+    $P534 = $P533."ast"()
+    store_lex "$past", $P534
+.annotate 'line', 78
+    find_lex $P536, "$/"
+    unless_null $P536, vivify_178
+    $P536 = root_new ['parrot';'Hash']
   vivify_178:
-    unless $P549, if_546_end
-    find_lex $P550, "$past"
-    find_lex $P551, "$/"
-    unless_null $P551, vivify_179
-    $P551 = root_new ['parrot';'Hash']
+    set $P537, $P536["quantifier"]
+    unless_null $P537, vivify_179
+    new $P537, "Undef"
   vivify_179:
-    set $P552, $P551["backmod"]
-    unless_null $P552, vivify_180
-    $P552 = root_new ['parrot';'ResizablePMCArray']
+    if $P537, if_535
+.annotate 'line', 84
+    find_lex $P554, "$/"
+    unless_null $P554, vivify_180
+    $P554 = root_new ['parrot';'Hash']
   vivify_180:
-    set $P553, $P552[0]
-    unless_null $P553, vivify_181
-    new $P553, "Undef"
+    set $P555, $P554["backmod"]
+    unless_null $P555, vivify_181
+    $P555 = root_new ['parrot';'ResizablePMCArray']
   vivify_181:
-    "backmod"($P550, $P553)
-  if_546_end:
-    goto if_528_end
-  if_528:
+    set $P556, $P555[0]
+    unless_null $P556, vivify_182
+    new $P556, "Undef"
+  vivify_182:
+    unless $P556, if_553_end
+    find_lex $P557, "$past"
+    find_lex $P558, "$/"
+    unless_null $P558, vivify_183
+    $P558 = root_new ['parrot';'Hash']
+  vivify_183:
+    set $P559, $P558["backmod"]
+    unless_null $P559, vivify_184
+    $P559 = root_new ['parrot';'ResizablePMCArray']
+  vivify_184:
+    set $P560, $P559[0]
+    unless_null $P560, vivify_185
+    new $P560, "Undef"
+  vivify_185:
+    "backmod"($P557, $P560)
+  if_553_end:
+    goto if_535_end
+  if_535:
 .annotate 'line', 78
-    .const 'Sub' $P532 = "37_1278500533.96053" 
-    capture_lex $P532
-    $P532()
-  if_528_end:
+    .const 'Sub' $P539 = "37_1279529222.65073" 
+    capture_lex $P539
+    $P539()
+  if_535_end:
 .annotate 'line', 85
-    find_lex $P559, "$past"
-    if $P559, if_558
-    set $P557, $P559
-    goto if_558_end
-  if_558:
-    find_lex $P560, "$past"
-    $P561 = $P560."backtrack"()
-    isfalse $I562, $P561
-    new $P557, 'Integer'
-    set $P557, $I562
-  if_558_end:
-    if $P557, if_556
-    set $P555, $P557
-    goto if_556_end
-  if_556:
-    get_global $P563, "@MODIFIERS"
-    unless_null $P563, vivify_185
-    $P563 = root_new ['parrot';'ResizablePMCArray']
-  vivify_185:
-    set $P564, $P563[0]
-    unless_null $P564, vivify_186
-    $P564 = root_new ['parrot';'Hash']
-  vivify_186:
-    set $P565, $P564["r"]
-    unless_null $P565, vivify_187
-    new $P565, "Undef"
-  vivify_187:
-    set $P555, $P565
-  if_556_end:
-    unless $P555, if_554_end
-.annotate 'line', 86
     find_lex $P566, "$past"
-    $P566."backtrack"("r")
-  if_554_end:
+    if $P566, if_565
+    set $P564, $P566
+    goto if_565_end
+  if_565:
+    find_lex $P567, "$past"
+    $P568 = $P567."backtrack"()
+    isfalse $I569, $P568
+    new $P564, 'Integer'
+    set $P564, $I569
+  if_565_end:
+    if $P564, if_563
+    set $P562, $P564
+    goto if_563_end
+  if_563:
+    get_global $P570, "@MODIFIERS"
+    unless_null $P570, vivify_189
+    $P570 = root_new ['parrot';'ResizablePMCArray']
+  vivify_189:
+    set $P571, $P570[0]
+    unless_null $P571, vivify_190
+    $P571 = root_new ['parrot';'Hash']
+  vivify_190:
+    set $P572, $P571["r"]
+    unless_null $P572, vivify_191
+    new $P572, "Undef"
+  vivify_191:
+    set $P562, $P572
+  if_563_end:
+    unless $P562, if_561_end
+.annotate 'line', 86
+    find_lex $P573, "$past"
+    $P573."backtrack"("r")
+  if_561_end:
 .annotate 'line', 88
-    find_lex $P567, "$/"
-    find_lex $P568, "$past"
-    $P569 = $P567."!make"($P568)
+    find_lex $P574, "$/"
+    find_lex $P575, "$past"
+    $P576 = $P574."!make"($P575)
 .annotate 'line', 76
-    .return ($P569)
-  control_521:
+    .return ($P576)
+  control_528:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P570, exception, "payload"
-    .return ($P570)
+    getattribute $P577, exception, "payload"
+    .return ($P577)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block531"  :anon :subid("37_1278500533.96053") :outer("36_1278500533.96053")
+.sub "_block538"  :anon :subid("37_1279529222.65073") :outer("36_1279529222.65073")
 .annotate 'line', 80
-    new $P533, "Undef"
-    .lex "$qast", $P533
+    new $P540, "Undef"
+    .lex "$qast", $P540
 .annotate 'line', 79
-    find_lex $P535, "$past"
-    isfalse $I536, $P535
-    unless $I536, if_534_end
-    find_lex $P537, "$/"
-    $P538 = $P537."CURSOR"()
-    $P538."panic"("Quantifier follows nothing")
-  if_534_end:
+    find_lex $P542, "$past"
+    isfalse $I543, $P542
+    unless $I543, if_541_end
+    find_lex $P544, "$/"
+    $P545 = $P544."CURSOR"()
+    $P545."panic"("Quantifier follows nothing")
+  if_541_end:
 .annotate 'line', 80
-    find_lex $P539, "$/"
-    unless_null $P539, vivify_182
-    $P539 = root_new ['parrot';'Hash']
-  vivify_182:
-    set $P540, $P539["quantifier"]
-    unless_null $P540, vivify_183
-    $P540 = root_new ['parrot';'ResizablePMCArray']
-  vivify_183:
-    set $P541, $P540[0]
-    unless_null $P541, vivify_184
-    new $P541, "Undef"
-  vivify_184:
-    $P542 = $P541."ast"()
-    store_lex "$qast", $P542
+    find_lex $P546, "$/"
+    unless_null $P546, vivify_186
+    $P546 = root_new ['parrot';'Hash']
+  vivify_186:
+    set $P547, $P546["quantifier"]
+    unless_null $P547, vivify_187
+    $P547 = root_new ['parrot';'ResizablePMCArray']
+  vivify_187:
+    set $P548, $P547[0]
+    unless_null $P548, vivify_188
+    new $P548, "Undef"
+  vivify_188:
+    $P549 = $P548."ast"()
+    store_lex "$qast", $P549
 .annotate 'line', 81
-    find_lex $P543, "$qast"
-    find_lex $P544, "$past"
-    $P543."unshift"($P544)
+    find_lex $P550, "$qast"
+    find_lex $P551, "$past"
+    $P550."unshift"($P551)
 .annotate 'line', 82
-    find_lex $P545, "$qast"
-    store_lex "$past", $P545
+    find_lex $P552, "$qast"
+    store_lex "$past", $P552
 .annotate 'line', 78
-    .return ($P545)
+    .return ($P552)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "atom"  :subid("38_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_574
+.sub "atom"  :subid("38_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_581
 .annotate 'line', 91
-    new $P573, 'ExceptionHandler'
-    set_addr $P573, control_572
-    $P573."handle_types"(.CONTROL_RETURN)
-    push_eh $P573
+    new $P580, 'ExceptionHandler'
+    set_addr $P580, control_579
+    $P580."handle_types"(.CONTROL_RETURN)
+    push_eh $P580
     .lex "self", self
-    .lex "$/", param_574
+    .lex "$/", param_581
 .annotate 'line', 92
-    new $P575, "Undef"
-    .lex "$past", $P575
+    new $P582, "Undef"
+    .lex "$past", $P582
 .annotate 'line', 91
-    find_lex $P576, "$past"
+    find_lex $P583, "$past"
 .annotate 'line', 93
-    find_lex $P578, "$/"
-    unless_null $P578, vivify_188
-    $P578 = root_new ['parrot';'Hash']
-  vivify_188:
-    set $P579, $P578["metachar"]
-    unless_null $P579, vivify_189
-    new $P579, "Undef"
-  vivify_189:
-    if $P579, if_577
+    find_lex $P585, "$/"
+    unless_null $P585, vivify_192
+    $P585 = root_new ['parrot';'Hash']
+  vivify_192:
+    set $P586, $P585["metachar"]
+    unless_null $P586, vivify_193
+    new $P586, "Undef"
+  vivify_193:
+    if $P586, if_584
 .annotate 'line', 95
-    get_hll_global $P583, ["PAST"], "Regex"
-    find_lex $P584, "$/"
-    set $S585, $P584
-    find_lex $P586, "$/"
-    $P587 = $P583."new"($S585, "literal" :named("pasttype"), $P586 :named("node"))
-    store_lex "$past", $P587
+    get_hll_global $P590, ["PAST"], "Regex"
+    find_lex $P591, "$/"
+    set $S592, $P591
+    find_lex $P593, "$/"
+    $P594 = $P590."new"($S592, "literal" :named("pasttype"), $P593 :named("node"))
+    store_lex "$past", $P594
 .annotate 'line', 96
-    get_global $P589, "@MODIFIERS"
-    unless_null $P589, vivify_190
-    $P589 = root_new ['parrot';'ResizablePMCArray']
-  vivify_190:
-    set $P590, $P589[0]
-    unless_null $P590, vivify_191
-    $P590 = root_new ['parrot';'Hash']
-  vivify_191:
-    set $P591, $P590["i"]
-    unless_null $P591, vivify_192
-    new $P591, "Undef"
-  vivify_192:
-    unless $P591, if_588_end
-    find_lex $P592, "$past"
-    $P592."subtype"("ignorecase")
-  if_588_end:
+    get_global $P596, "@MODIFIERS"
+    unless_null $P596, vivify_194
+    $P596 = root_new ['parrot';'ResizablePMCArray']
+  vivify_194:
+    set $P597, $P596[0]
+    unless_null $P597, vivify_195
+    $P597 = root_new ['parrot';'Hash']
+  vivify_195:
+    set $P598, $P597["i"]
+    unless_null $P598, vivify_196
+    new $P598, "Undef"
+  vivify_196:
+    unless $P598, if_595_end
+    find_lex $P599, "$past"
+    $P599."subtype"("ignorecase")
+  if_595_end:
 .annotate 'line', 94
-    goto if_577_end
-  if_577:
+    goto if_584_end
+  if_584:
 .annotate 'line', 93
-    find_lex $P580, "$/"
-    unless_null $P580, vivify_193
-    $P580 = root_new ['parrot';'Hash']
-  vivify_193:
-    set $P581, $P580["metachar"]
-    unless_null $P581, vivify_194
-    new $P581, "Undef"
-  vivify_194:
-    $P582 = $P581."ast"()
-    store_lex "$past", $P582
-  if_577_end:
+    find_lex $P587, "$/"
+    unless_null $P587, vivify_197
+    $P587 = root_new ['parrot';'Hash']
+  vivify_197:
+    set $P588, $P587["metachar"]
+    unless_null $P588, vivify_198
+    new $P588, "Undef"
+  vivify_198:
+    $P589 = $P588."ast"()
+    store_lex "$past", $P589
+  if_584_end:
 .annotate 'line', 98
-    find_lex $P593, "$/"
-    find_lex $P594, "$past"
-    $P595 = $P593."!make"($P594)
+    find_lex $P600, "$/"
+    find_lex $P601, "$past"
+    $P602 = $P600."!make"($P601)
 .annotate 'line', 91
-    .return ($P595)
-  control_572:
+    .return ($P602)
+  control_579:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P596, exception, "payload"
-    .return ($P596)
+    getattribute $P603, exception, "payload"
+    .return ($P603)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "quantifier:sym<*>"  :subid("39_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_600
+.sub "quantifier:sym<*>"  :subid("39_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_607
 .annotate 'line', 101
-    new $P599, 'ExceptionHandler'
-    set_addr $P599, control_598
-    $P599."handle_types"(.CONTROL_RETURN)
-    push_eh $P599
+    new $P606, 'ExceptionHandler'
+    set_addr $P606, control_605
+    $P606."handle_types"(.CONTROL_RETURN)
+    push_eh $P606
     .lex "self", self
-    .lex "$/", param_600
+    .lex "$/", param_607
 .annotate 'line', 102
-    new $P601, "Undef"
-    .lex "$past", $P601
-    get_hll_global $P602, ["PAST"], "Regex"
-    find_lex $P603, "$/"
-    $P604 = $P602."new"("quant" :named("pasttype"), $P603 :named("node"))
-    store_lex "$past", $P604
-.annotate 'line', 103
-    find_lex $P605, "$/"
-    find_lex $P606, "$past"
-    find_lex $P607, "$/"
-    unless_null $P607, vivify_195
-    $P607 = root_new ['parrot';'Hash']
-  vivify_195:
-    set $P608, $P607["backmod"]
-    unless_null $P608, vivify_196
     new $P608, "Undef"
-  vivify_196:
-    $P609 = "backmod"($P606, $P608)
-    $P610 = $P605."!make"($P609)
+    .lex "$past", $P608
+    get_hll_global $P609, ["PAST"], "Regex"
+    find_lex $P610, "$/"
+    $P611 = $P609."new"("quant" :named("pasttype"), $P610 :named("node"))
+    store_lex "$past", $P611
+.annotate 'line', 103
+    find_lex $P612, "$/"
+    find_lex $P613, "$past"
+    find_lex $P614, "$/"
+    unless_null $P614, vivify_199
+    $P614 = root_new ['parrot';'Hash']
+  vivify_199:
+    set $P615, $P614["backmod"]
+    unless_null $P615, vivify_200
+    new $P615, "Undef"
+  vivify_200:
+    $P616 = "backmod"($P613, $P615)
+    $P617 = $P612."!make"($P616)
 .annotate 'line', 101
-    .return ($P610)
-  control_598:
+    .return ($P617)
+  control_605:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P611, exception, "payload"
-    .return ($P611)
+    getattribute $P618, exception, "payload"
+    .return ($P618)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "quantifier:sym<+>"  :subid("40_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_615
+.sub "quantifier:sym<+>"  :subid("40_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_622
 .annotate 'line', 106
-    new $P614, 'ExceptionHandler'
-    set_addr $P614, control_613
-    $P614."handle_types"(.CONTROL_RETURN)
-    push_eh $P614
+    new $P621, 'ExceptionHandler'
+    set_addr $P621, control_620
+    $P621."handle_types"(.CONTROL_RETURN)
+    push_eh $P621
     .lex "self", self
-    .lex "$/", param_615
+    .lex "$/", param_622
 .annotate 'line', 107
-    new $P616, "Undef"
-    .lex "$past", $P616
-    get_hll_global $P617, ["PAST"], "Regex"
-    find_lex $P618, "$/"
-    $P619 = $P617."new"("quant" :named("pasttype"), 1 :named("min"), $P618 :named("node"))
-    store_lex "$past", $P619
-.annotate 'line', 108
-    find_lex $P620, "$/"
-    find_lex $P621, "$past"
-    find_lex $P622, "$/"
-    unless_null $P622, vivify_197
-    $P622 = root_new ['parrot';'Hash']
-  vivify_197:
-    set $P623, $P622["backmod"]
-    unless_null $P623, vivify_198
     new $P623, "Undef"
-  vivify_198:
-    $P624 = "backmod"($P621, $P623)
-    $P625 = $P620."!make"($P624)
+    .lex "$past", $P623
+    get_hll_global $P624, ["PAST"], "Regex"
+    find_lex $P625, "$/"
+    $P626 = $P624."new"("quant" :named("pasttype"), 1 :named("min"), $P625 :named("node"))
+    store_lex "$past", $P626
+.annotate 'line', 108
+    find_lex $P627, "$/"
+    find_lex $P628, "$past"
+    find_lex $P629, "$/"
+    unless_null $P629, vivify_201
+    $P629 = root_new ['parrot';'Hash']
+  vivify_201:
+    set $P630, $P629["backmod"]
+    unless_null $P630, vivify_202
+    new $P630, "Undef"
+  vivify_202:
+    $P631 = "backmod"($P628, $P630)
+    $P632 = $P627."!make"($P631)
 .annotate 'line', 106
-    .return ($P625)
-  control_613:
+    .return ($P632)
+  control_620:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P626, exception, "payload"
-    .return ($P626)
+    getattribute $P633, exception, "payload"
+    .return ($P633)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "quantifier:sym<?>"  :subid("41_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_630
+.sub "quantifier:sym<?>"  :subid("41_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_637
 .annotate 'line', 111
-    new $P629, 'ExceptionHandler'
-    set_addr $P629, control_628
-    $P629."handle_types"(.CONTROL_RETURN)
-    push_eh $P629
+    new $P636, 'ExceptionHandler'
+    set_addr $P636, control_635
+    $P636."handle_types"(.CONTROL_RETURN)
+    push_eh $P636
     .lex "self", self
-    .lex "$/", param_630
+    .lex "$/", param_637
 .annotate 'line', 112
-    new $P631, "Undef"
-    .lex "$past", $P631
-    get_hll_global $P632, ["PAST"], "Regex"
-    find_lex $P633, "$/"
-    $P634 = $P632."new"("quant" :named("pasttype"), 0 :named("min"), 1 :named("max"), $P633 :named("node"))
-    store_lex "$past", $P634
-.annotate 'line', 113
-    find_lex $P635, "$/"
-    find_lex $P636, "$past"
-    find_lex $P637, "$/"
-    unless_null $P637, vivify_199
-    $P637 = root_new ['parrot';'Hash']
-  vivify_199:
-    set $P638, $P637["backmod"]
-    unless_null $P638, vivify_200
     new $P638, "Undef"
-  vivify_200:
-    $P639 = "backmod"($P636, $P638)
-    $P635."!make"($P639)
-.annotate 'line', 114
+    .lex "$past", $P638
+    get_hll_global $P639, ["PAST"], "Regex"
     find_lex $P640, "$/"
-    find_lex $P641, "$past"
-    $P642 = $P640."!make"($P641)
+    $P641 = $P639."new"("quant" :named("pasttype"), 0 :named("min"), 1 :named("max"), $P640 :named("node"))
+    store_lex "$past", $P641
+.annotate 'line', 113
+    find_lex $P642, "$/"
+    find_lex $P643, "$past"
+    find_lex $P644, "$/"
+    unless_null $P644, vivify_203
+    $P644 = root_new ['parrot';'Hash']
+  vivify_203:
+    set $P645, $P644["backmod"]
+    unless_null $P645, vivify_204
+    new $P645, "Undef"
+  vivify_204:
+    $P646 = "backmod"($P643, $P645)
+    $P642."!make"($P646)
+.annotate 'line', 114
+    find_lex $P647, "$/"
+    find_lex $P648, "$past"
+    $P649 = $P647."!make"($P648)
 .annotate 'line', 111
-    .return ($P642)
-  control_628:
+    .return ($P649)
+  control_635:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P643, exception, "payload"
-    .return ($P643)
+    getattribute $P650, exception, "payload"
+    .return ($P650)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "quantifier:sym<**>"  :subid("42_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_647
+.sub "quantifier:sym<**>"  :subid("42_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_654
 .annotate 'line', 117
-    .const 'Sub' $P662 = "43_1278500533.96053" 
-    capture_lex $P662
-    new $P646, 'ExceptionHandler'
-    set_addr $P646, control_645
-    $P646."handle_types"(.CONTROL_RETURN)
-    push_eh $P646
+    .const 'Sub' $P669 = "43_1279529222.65073" 
+    capture_lex $P669
+    new $P653, 'ExceptionHandler'
+    set_addr $P653, control_652
+    $P653."handle_types"(.CONTROL_RETURN)
+    push_eh $P653
     .lex "self", self
-    .lex "$/", param_647
+    .lex "$/", param_654
 .annotate 'line', 118
-    new $P648, "Undef"
-    .lex "$past", $P648
+    new $P655, "Undef"
+    .lex "$past", $P655
 .annotate 'line', 119
-    new $P649, "Undef"
-    .lex "$ws", $P649
+    new $P656, "Undef"
+    .lex "$ws", $P656
 .annotate 'line', 117
-    find_lex $P650, "$past"
+    find_lex $P657, "$past"
 .annotate 'line', 119
-    find_lex $P653, "$/"
-    unless_null $P653, vivify_201
-    $P653 = root_new ['parrot';'Hash']
-  vivify_201:
-    set $P654, $P653["normspace"]
-    unless_null $P654, vivify_202
-    new $P654, "Undef"
-  vivify_202:
-    if $P654, if_652
-    set $P651, $P654
-    goto if_652_end
-  if_652:
-    get_global $P655, "@MODIFIERS"
-    unless_null $P655, vivify_203
-    $P655 = root_new ['parrot';'ResizablePMCArray']
-  vivify_203:
-    set $P656, $P655[0]
-    unless_null $P656, vivify_204
-    $P656 = root_new ['parrot';'Hash']
-  vivify_204:
-    set $P657, $P656["s"]
-    unless_null $P657, vivify_205
-    new $P657, "Undef"
+    find_lex $P660, "$/"
+    unless_null $P660, vivify_205
+    $P660 = root_new ['parrot';'Hash']
   vivify_205:
-    set $P651, $P657
-  if_652_end:
-    store_lex "$ws", $P651
-.annotate 'line', 120
-    find_lex $P659, "$/"
-    unless_null $P659, vivify_206
-    $P659 = root_new ['parrot';'Hash']
+    set $P661, $P660["normspace"]
+    unless_null $P661, vivify_206
+    new $P661, "Undef"
   vivify_206:
-    set $P660, $P659["quantified_atom"]
-    unless_null $P660, vivify_207
-    new $P660, "Undef"
+    if $P661, if_659
+    set $P658, $P661
+    goto if_659_end
+  if_659:
+    get_global $P662, "@MODIFIERS"
+    unless_null $P662, vivify_207
+    $P662 = root_new ['parrot';'ResizablePMCArray']
   vivify_207:
-    if $P660, if_658
-.annotate 'line', 136
-    get_hll_global $P680, ["PAST"], "Regex"
-    find_lex $P681, "$/"
-    unless_null $P681, vivify_208
-    $P681 = root_new ['parrot';'Hash']
+    set $P663, $P662[0]
+    unless_null $P663, vivify_208
+    $P663 = root_new ['parrot';'Hash']
   vivify_208:
-    set $P682, $P681["min"]
-    unless_null $P682, vivify_209
-    new $P682, "Undef"
+    set $P664, $P663["s"]
+    unless_null $P664, vivify_209
+    new $P664, "Undef"
   vivify_209:
-    set $N683, $P682
-    find_lex $P684, "$/"
-    $P685 = $P680."new"("quant" :named("pasttype"), $N683 :named("min"), $P684 :named("node"))
-    store_lex "$past", $P685
-.annotate 'line', 137
-    find_lex $P687, "$/"
-    unless_null $P687, vivify_210
-    $P687 = root_new ['parrot';'Hash']
+    set $P658, $P664
+  if_659_end:
+    store_lex "$ws", $P658
+.annotate 'line', 120
+    find_lex $P666, "$/"
+    unless_null $P666, vivify_210
+    $P666 = root_new ['parrot';'Hash']
   vivify_210:
-    set $P688, $P687["max"]
-    unless_null $P688, vivify_211
-    new $P688, "Undef"
+    set $P667, $P666["quantified_atom"]
+    unless_null $P667, vivify_211
+    new $P667, "Undef"
   vivify_211:
-    isfalse $I689, $P688
-    if $I689, if_686
-.annotate 'line', 138
-    find_lex $P695, "$/"
-    unless_null $P695, vivify_212
-    $P695 = root_new ['parrot';'Hash']
+    if $P667, if_665
+.annotate 'line', 136
+    get_hll_global $P687, ["PAST"], "Regex"
+    find_lex $P688, "$/"
+    unless_null $P688, vivify_212
+    $P688 = root_new ['parrot';'Hash']
   vivify_212:
-    set $P696, $P695["max"]
-    unless_null $P696, vivify_213
-    $P696 = root_new ['parrot';'ResizablePMCArray']
+    set $P689, $P688["min"]
+    unless_null $P689, vivify_213
+    new $P689, "Undef"
   vivify_213:
-    set $P697, $P696[0]
-    unless_null $P697, vivify_214
-    new $P697, "Undef"
+    set $N690, $P689
+    find_lex $P691, "$/"
+    $P692 = $P687."new"("quant" :named("pasttype"), $N690 :named("min"), $P691 :named("node"))
+    store_lex "$past", $P692
+.annotate 'line', 137
+    find_lex $P694, "$/"
+    unless_null $P694, vivify_214
+    $P694 = root_new ['parrot';'Hash']
   vivify_214:
-    set $S698, $P697
-    isne $I699, $S698, "*"
-    unless $I699, if_694_end
-    find_lex $P700, "$past"
-    find_lex $P701, "$/"
-    unless_null $P701, vivify_215
-    $P701 = root_new ['parrot';'Hash']
+    set $P695, $P694["max"]
+    unless_null $P695, vivify_215
+    new $P695, "Undef"
   vivify_215:
-    set $P702, $P701["max"]
+    isfalse $I696, $P695
+    if $I696, if_693
+.annotate 'line', 138
+    find_lex $P702, "$/"
     unless_null $P702, vivify_216
-    $P702 = root_new ['parrot';'ResizablePMCArray']
+    $P702 = root_new ['parrot';'Hash']
   vivify_216:
-    set $P703, $P702[0]
+    set $P703, $P702["max"]
     unless_null $P703, vivify_217
-    new $P703, "Undef"
+    $P703 = root_new ['parrot';'ResizablePMCArray']
   vivify_217:
-    set $N704, $P703
-    $P700."max"($N704)
-  if_694_end:
-    goto if_686_end
-  if_686:
-.annotate 'line', 137
-    find_lex $P690, "$past"
-    find_lex $P691, "$/"
-    unless_null $P691, vivify_218
-    $P691 = root_new ['parrot';'Hash']
+    set $P704, $P703[0]
+    unless_null $P704, vivify_218
+    new $P704, "Undef"
   vivify_218:
-    set $P692, $P691["min"]
-    unless_null $P692, vivify_219
-    new $P692, "Undef"
+    set $S705, $P704
+    isne $I706, $S705, "*"
+    unless $I706, if_701_end
+    find_lex $P707, "$past"
+    find_lex $P708, "$/"
+    unless_null $P708, vivify_219
+    $P708 = root_new ['parrot';'Hash']
   vivify_219:
-    set $N693, $P692
-    $P690."max"($N693)
-  if_686_end:
+    set $P709, $P708["max"]
+    unless_null $P709, vivify_220
+    $P709 = root_new ['parrot';'ResizablePMCArray']
+  vivify_220:
+    set $P710, $P709[0]
+    unless_null $P710, vivify_221
+    new $P710, "Undef"
+  vivify_221:
+    set $N711, $P710
+    $P707."max"($N711)
+  if_701_end:
+    goto if_693_end
+  if_693:
+.annotate 'line', 137
+    find_lex $P697, "$past"
+    find_lex $P698, "$/"
+    unless_null $P698, vivify_222
+    $P698 = root_new ['parrot';'Hash']
+  vivify_222:
+    set $P699, $P698["min"]
+    unless_null $P699, vivify_223
+    new $P699, "Undef"
+  vivify_223:
+    set $N700, $P699
+    $P697."max"($N700)
+  if_693_end:
 .annotate 'line', 139
-    find_lex $P706, "$ws"
-    unless $P706, if_705_end
-    find_lex $P707, "$past"
-    get_hll_global $P708, ["PAST"], "Regex"
-    $P709 = $P708."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"))
-    $P707."sep"($P709)
-  if_705_end:
+    find_lex $P713, "$ws"
+    unless $P713, if_712_end
+    find_lex $P714, "$past"
+    get_hll_global $P715, ["PAST"], "Regex"
+    $P716 = $P715."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"))
+    $P714."sep"($P716)
+  if_712_end:
 .annotate 'line', 135
-    goto if_658_end
-  if_658:
+    goto if_665_end
+  if_665:
 .annotate 'line', 120
-    .const 'Sub' $P662 = "43_1278500533.96053" 
-    capture_lex $P662
-    $P662()
-  if_658_end:
+    .const 'Sub' $P669 = "43_1279529222.65073" 
+    capture_lex $P669
+    $P669()
+  if_665_end:
 .annotate 'line', 143
-    find_lex $P710, "$/"
-    find_lex $P711, "$past"
-    find_lex $P712, "$/"
-    unless_null $P712, vivify_222
-    $P712 = root_new ['parrot';'Hash']
-  vivify_222:
-    set $P713, $P712["backmod"]
-    unless_null $P713, vivify_223
-    new $P713, "Undef"
-  vivify_223:
-    $P714 = "backmod"($P711, $P713)
-    $P715 = $P710."!make"($P714)
+    find_lex $P717, "$/"
+    find_lex $P718, "$past"
+    find_lex $P719, "$/"
+    unless_null $P719, vivify_226
+    $P719 = root_new ['parrot';'Hash']
+  vivify_226:
+    set $P720, $P719["backmod"]
+    unless_null $P720, vivify_227
+    new $P720, "Undef"
+  vivify_227:
+    $P721 = "backmod"($P718, $P720)
+    $P722 = $P717."!make"($P721)
 .annotate 'line', 117
-    .return ($P715)
-  control_645:
+    .return ($P722)
+  control_652:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P716, exception, "payload"
-    .return ($P716)
+    getattribute $P723, exception, "payload"
+    .return ($P723)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block661"  :anon :subid("43_1278500533.96053") :outer("42_1278500533.96053")
+.sub "_block668"  :anon :subid("43_1279529222.65073") :outer("42_1279529222.65073")
 .annotate 'line', 121
-    new $P663, "Undef"
-    .lex "$ast", $P663
-    find_lex $P664, "$/"
-    unless_null $P664, vivify_220
-    $P664 = root_new ['parrot';'Hash']
-  vivify_220:
-    set $P665, $P664["quantified_atom"]
-    unless_null $P665, vivify_221
-    new $P665, "Undef"
-  vivify_221:
-    $P666 = $P665."ast"()
-    store_lex "$ast", $P666
+    new $P670, "Undef"
+    .lex "$ast", $P670
+    find_lex $P671, "$/"
+    unless_null $P671, vivify_224
+    $P671 = root_new ['parrot';'Hash']
+  vivify_224:
+    set $P672, $P671["quantified_atom"]
+    unless_null $P672, vivify_225
+    new $P672, "Undef"
+  vivify_225:
+    $P673 = $P672."ast"()
+    store_lex "$ast", $P673
 .annotate 'line', 122
-    find_lex $P668, "$ws"
-    unless $P668, if_667_end
+    find_lex $P675, "$ws"
+    unless $P675, if_674_end
 .annotate 'line', 123
-    get_hll_global $P669, ["PAST"], "Regex"
+    get_hll_global $P676, ["PAST"], "Regex"
 .annotate 'line', 125
-    get_hll_global $P670, ["PAST"], "Regex"
-    $P671 = $P670."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"))
-    find_lex $P672, "$ast"
+    get_hll_global $P677, ["PAST"], "Regex"
+    $P678 = $P677."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"))
+    find_lex $P679, "$ast"
 .annotate 'line', 128
-    get_hll_global $P673, ["PAST"], "Regex"
-    $P674 = $P673."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"))
-    $P675 = $P669."new"($P671, $P672, $P674, "concat" :named("pasttype"))
+    get_hll_global $P680, ["PAST"], "Regex"
+    $P681 = $P680."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"))
+    $P682 = $P676."new"($P678, $P679, $P681, "concat" :named("pasttype"))
 .annotate 'line', 123
-    store_lex "$ast", $P675
-  if_667_end:
+    store_lex "$ast", $P682
+  if_674_end:
 .annotate 'line', 132
-    get_hll_global $P676, ["PAST"], "Regex"
-    find_lex $P677, "$ast"
-    find_lex $P678, "$/"
-    $P679 = $P676."new"("quant" :named("pasttype"), 1 :named("min"), $P677 :named("sep"), $P678 :named("node"))
-    store_lex "$past", $P679
+    get_hll_global $P683, ["PAST"], "Regex"
+    find_lex $P684, "$ast"
+    find_lex $P685, "$/"
+    $P686 = $P683."new"("quant" :named("pasttype"), 1 :named("min"), $P684 :named("sep"), $P685 :named("node"))
+    store_lex "$past", $P686
 .annotate 'line', 120
-    .return ($P679)
+    .return ($P686)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<ws>"  :subid("44_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_720
+.sub "metachar:sym<ws>"  :subid("44_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_727
 .annotate 'line', 146
-    new $P719, 'ExceptionHandler'
-    set_addr $P719, control_718
-    $P719."handle_types"(.CONTROL_RETURN)
-    push_eh $P719
+    new $P726, 'ExceptionHandler'
+    set_addr $P726, control_725
+    $P726."handle_types"(.CONTROL_RETURN)
+    push_eh $P726
     .lex "self", self
-    .lex "$/", param_720
+    .lex "$/", param_727
 .annotate 'line', 147
-    new $P721, "Undef"
-    .lex "$past", $P721
+    new $P728, "Undef"
+    .lex "$past", $P728
 .annotate 'line', 148
-    get_global $P724, "@MODIFIERS"
-    unless_null $P724, vivify_224
-    $P724 = root_new ['parrot';'ResizablePMCArray']
-  vivify_224:
-    set $P725, $P724[0]
-    unless_null $P725, vivify_225
-    $P725 = root_new ['parrot';'Hash']
-  vivify_225:
-    set $P726, $P725["s"]
-    unless_null $P726, vivify_226
-    new $P726, "Undef"
-  vivify_226:
-    if $P726, if_723
-    new $P730, "Integer"
-    assign $P730, 0
-    set $P722, $P730
-    goto if_723_end
-  if_723:
-    get_hll_global $P727, ["PAST"], "Regex"
-    find_lex $P728, "$/"
-    $P729 = $P727."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"), $P728 :named("node"))
-    set $P722, $P729
-  if_723_end:
-    store_lex "$past", $P722
+    get_global $P731, "@MODIFIERS"
+    unless_null $P731, vivify_228
+    $P731 = root_new ['parrot';'ResizablePMCArray']
+  vivify_228:
+    set $P732, $P731[0]
+    unless_null $P732, vivify_229
+    $P732 = root_new ['parrot';'Hash']
+  vivify_229:
+    set $P733, $P732["s"]
+    unless_null $P733, vivify_230
+    new $P733, "Undef"
+  vivify_230:
+    if $P733, if_730
+    new $P737, "Integer"
+    assign $P737, 0
+    set $P729, $P737
+    goto if_730_end
+  if_730:
+    get_hll_global $P734, ["PAST"], "Regex"
+    find_lex $P735, "$/"
+    $P736 = $P734."new"("ws", "subrule" :named("pasttype"), "method" :named("subtype"), $P735 :named("node"))
+    set $P729, $P736
+  if_730_end:
+    store_lex "$past", $P729
 .annotate 'line', 151
-    find_lex $P731, "$/"
-    find_lex $P732, "$past"
-    $P733 = $P731."!make"($P732)
+    find_lex $P738, "$/"
+    find_lex $P739, "$past"
+    $P740 = $P738."!make"($P739)
 .annotate 'line', 146
-    .return ($P733)
-  control_718:
+    .return ($P740)
+  control_725:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P734, exception, "payload"
-    .return ($P734)
+    getattribute $P741, exception, "payload"
+    .return ($P741)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<[ ]>"  :subid("45_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_738
+.sub "metachar:sym<[ ]>"  :subid("45_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_745
 .annotate 'line', 155
-    new $P737, 'ExceptionHandler'
-    set_addr $P737, control_736
-    $P737."handle_types"(.CONTROL_RETURN)
-    push_eh $P737
+    new $P744, 'ExceptionHandler'
+    set_addr $P744, control_743
+    $P744."handle_types"(.CONTROL_RETURN)
+    push_eh $P744
     .lex "self", self
-    .lex "$/", param_738
+    .lex "$/", param_745
 .annotate 'line', 156
-    find_lex $P739, "$/"
-    find_lex $P740, "$/"
-    unless_null $P740, vivify_227
-    $P740 = root_new ['parrot';'Hash']
-  vivify_227:
-    set $P741, $P740["nibbler"]
-    unless_null $P741, vivify_228
-    new $P741, "Undef"
-  vivify_228:
-    $P742 = $P741."ast"()
-    $P743 = $P739."!make"($P742)
+    find_lex $P746, "$/"
+    find_lex $P747, "$/"
+    unless_null $P747, vivify_231
+    $P747 = root_new ['parrot';'Hash']
+  vivify_231:
+    set $P748, $P747["nibbler"]
+    unless_null $P748, vivify_232
+    new $P748, "Undef"
+  vivify_232:
+    $P749 = $P748."ast"()
+    $P750 = $P746."!make"($P749)
 .annotate 'line', 155
-    .return ($P743)
-  control_736:
+    .return ($P750)
+  control_743:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P744, exception, "payload"
-    .return ($P744)
+    getattribute $P751, exception, "payload"
+    .return ($P751)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<( )>"  :subid("46_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_748
+.sub "metachar:sym<( )>"  :subid("46_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_755
 .annotate 'line', 159
-    new $P747, 'ExceptionHandler'
-    set_addr $P747, control_746
-    $P747."handle_types"(.CONTROL_RETURN)
-    push_eh $P747
+    new $P754, 'ExceptionHandler'
+    set_addr $P754, control_753
+    $P754."handle_types"(.CONTROL_RETURN)
+    push_eh $P754
     .lex "self", self
-    .lex "$/", param_748
+    .lex "$/", param_755
 .annotate 'line', 160
-    new $P749, "Undef"
-    .lex "$subpast", $P749
+    new $P756, "Undef"
+    .lex "$subpast", $P756
 .annotate 'line', 161
-    new $P750, "Undef"
-    .lex "$past", $P750
+    new $P757, "Undef"
+    .lex "$past", $P757
 .annotate 'line', 160
-    find_lex $P751, "$/"
-    unless_null $P751, vivify_229
-    $P751 = root_new ['parrot';'Hash']
-  vivify_229:
-    set $P752, $P751["nibbler"]
-    unless_null $P752, vivify_230
-    new $P752, "Undef"
-  vivify_230:
-    $P753 = $P752."ast"()
-    $P754 = "buildsub"($P753)
-    store_lex "$subpast", $P754
+    find_lex $P758, "$/"
+    unless_null $P758, vivify_233
+    $P758 = root_new ['parrot';'Hash']
+  vivify_233:
+    set $P759, $P758["nibbler"]
+    unless_null $P759, vivify_234
+    new $P759, "Undef"
+  vivify_234:
+    $P760 = $P759."ast"()
+    $P761 = "buildsub"($P760)
+    store_lex "$subpast", $P761
 .annotate 'line', 161
-    get_hll_global $P755, ["PAST"], "Regex"
-    find_lex $P756, "$subpast"
-    find_lex $P757, "$/"
-    $P758 = $P755."new"($P756, "subrule" :named("pasttype"), "capture" :named("subtype"), $P757 :named("node"))
-    store_lex "$past", $P758
+    get_hll_global $P762, ["PAST"], "Regex"
+    find_lex $P763, "$subpast"
+    find_lex $P764, "$/"
+    $P765 = $P762."new"($P763, "subrule" :named("pasttype"), "capture" :named("subtype"), $P764 :named("node"))
+    store_lex "$past", $P765
 .annotate 'line', 163
-    find_lex $P759, "$/"
-    find_lex $P760, "$past"
-    $P761 = $P759."!make"($P760)
+    find_lex $P766, "$/"
+    find_lex $P767, "$past"
+    $P768 = $P766."!make"($P767)
 .annotate 'line', 159
-    .return ($P761)
-  control_746:
+    .return ($P768)
+  control_753:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P762, exception, "payload"
-    .return ($P762)
+    getattribute $P769, exception, "payload"
+    .return ($P769)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<'>"  :subid("47_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_766
+.sub "metachar:sym<'>"  :subid("47_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_773
 .annotate 'line', 166
-    new $P765, 'ExceptionHandler'
-    set_addr $P765, control_764
-    $P765."handle_types"(.CONTROL_RETURN)
-    push_eh $P765
+    new $P772, 'ExceptionHandler'
+    set_addr $P772, control_771
+    $P772."handle_types"(.CONTROL_RETURN)
+    push_eh $P772
     .lex "self", self
-    .lex "$/", param_766
+    .lex "$/", param_773
 .annotate 'line', 167
-    new $P767, "Undef"
-    .lex "$quote", $P767
+    new $P774, "Undef"
+    .lex "$quote", $P774
 .annotate 'line', 169
-    new $P768, "Undef"
-    .lex "$past", $P768
+    new $P775, "Undef"
+    .lex "$past", $P775
 .annotate 'line', 167
-    find_lex $P769, "$/"
-    unless_null $P769, vivify_231
-    $P769 = root_new ['parrot';'Hash']
-  vivify_231:
-    set $P770, $P769["quote_EXPR"]
-    unless_null $P770, vivify_232
-    new $P770, "Undef"
-  vivify_232:
-    $P771 = $P770."ast"()
-    store_lex "$quote", $P771
+    find_lex $P776, "$/"
+    unless_null $P776, vivify_235
+    $P776 = root_new ['parrot';'Hash']
+  vivify_235:
+    set $P777, $P776["quote_EXPR"]
+    unless_null $P777, vivify_236
+    new $P777, "Undef"
+  vivify_236:
+    $P778 = $P777."ast"()
+    store_lex "$quote", $P778
 .annotate 'line', 168
-    get_hll_global $P773, ["PAST"], "Val"
-    find_lex $P774, "$quote"
-    $P775 = $P773."ACCEPTS"($P774)
-    unless $P775, if_772_end
-    find_lex $P776, "$quote"
-    $P777 = $P776."value"()
-    store_lex "$quote", $P777
-  if_772_end:
+    get_hll_global $P780, ["PAST"], "Val"
+    find_lex $P781, "$quote"
+    $P782 = $P780."ACCEPTS"($P781)
+    unless $P782, if_779_end
+    find_lex $P783, "$quote"
+    $P784 = $P783."value"()
+    store_lex "$quote", $P784
+  if_779_end:
 .annotate 'line', 169
-    get_hll_global $P778, ["PAST"], "Regex"
-    find_lex $P779, "$quote"
-    find_lex $P780, "$/"
-    $P781 = $P778."new"($P779, "literal" :named("pasttype"), $P780 :named("node"))
-    store_lex "$past", $P781
+    get_hll_global $P785, ["PAST"], "Regex"
+    find_lex $P786, "$quote"
+    find_lex $P787, "$/"
+    $P788 = $P785."new"($P786, "literal" :named("pasttype"), $P787 :named("node"))
+    store_lex "$past", $P788
 .annotate 'line', 170
-    find_lex $P782, "$/"
-    find_lex $P783, "$past"
-    $P784 = $P782."!make"($P783)
+    find_lex $P789, "$/"
+    find_lex $P790, "$past"
+    $P791 = $P789."!make"($P790)
 .annotate 'line', 166
-    .return ($P784)
-  control_764:
+    .return ($P791)
+  control_771:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P785, exception, "payload"
-    .return ($P785)
+    getattribute $P792, exception, "payload"
+    .return ($P792)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<\">"  :subid("48_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_789
+.sub "metachar:sym<\">"  :subid("48_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_796
 .annotate 'line', 173
-    new $P788, 'ExceptionHandler'
-    set_addr $P788, control_787
-    $P788."handle_types"(.CONTROL_RETURN)
-    push_eh $P788
+    new $P795, 'ExceptionHandler'
+    set_addr $P795, control_794
+    $P795."handle_types"(.CONTROL_RETURN)
+    push_eh $P795
     .lex "self", self
-    .lex "$/", param_789
+    .lex "$/", param_796
 .annotate 'line', 174
-    new $P790, "Undef"
-    .lex "$quote", $P790
+    new $P797, "Undef"
+    .lex "$quote", $P797
 .annotate 'line', 176
-    new $P791, "Undef"
-    .lex "$past", $P791
+    new $P798, "Undef"
+    .lex "$past", $P798
 .annotate 'line', 174
-    find_lex $P792, "$/"
-    unless_null $P792, vivify_233
-    $P792 = root_new ['parrot';'Hash']
-  vivify_233:
-    set $P793, $P792["quote_EXPR"]
-    unless_null $P793, vivify_234
-    new $P793, "Undef"
-  vivify_234:
-    $P794 = $P793."ast"()
-    store_lex "$quote", $P794
+    find_lex $P799, "$/"
+    unless_null $P799, vivify_237
+    $P799 = root_new ['parrot';'Hash']
+  vivify_237:
+    set $P800, $P799["quote_EXPR"]
+    unless_null $P800, vivify_238
+    new $P800, "Undef"
+  vivify_238:
+    $P801 = $P800."ast"()
+    store_lex "$quote", $P801
 .annotate 'line', 175
-    get_hll_global $P796, ["PAST"], "Val"
-    find_lex $P797, "$quote"
-    $P798 = $P796."ACCEPTS"($P797)
-    unless $P798, if_795_end
-    find_lex $P799, "$quote"
-    $P800 = $P799."value"()
-    store_lex "$quote", $P800
-  if_795_end:
+    get_hll_global $P803, ["PAST"], "Val"
+    find_lex $P804, "$quote"
+    $P805 = $P803."ACCEPTS"($P804)
+    unless $P805, if_802_end
+    find_lex $P806, "$quote"
+    $P807 = $P806."value"()
+    store_lex "$quote", $P807
+  if_802_end:
 .annotate 'line', 176
-    get_hll_global $P801, ["PAST"], "Regex"
-    find_lex $P802, "$quote"
-    find_lex $P803, "$/"
-    $P804 = $P801."new"($P802, "literal" :named("pasttype"), $P803 :named("node"))
-    store_lex "$past", $P804
+    get_hll_global $P808, ["PAST"], "Regex"
+    find_lex $P809, "$quote"
+    find_lex $P810, "$/"
+    $P811 = $P808."new"($P809, "literal" :named("pasttype"), $P810 :named("node"))
+    store_lex "$past", $P811
 .annotate 'line', 177
-    find_lex $P805, "$/"
-    find_lex $P806, "$past"
-    $P807 = $P805."!make"($P806)
+    find_lex $P812, "$/"
+    find_lex $P813, "$past"
+    $P814 = $P812."!make"($P813)
 .annotate 'line', 173
-    .return ($P807)
-  control_787:
+    .return ($P814)
+  control_794:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P808, exception, "payload"
-    .return ($P808)
+    getattribute $P815, exception, "payload"
+    .return ($P815)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<.>"  :subid("49_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_812
+.sub "metachar:sym<.>"  :subid("49_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_819
 .annotate 'line', 180
-    new $P811, 'ExceptionHandler'
-    set_addr $P811, control_810
-    $P811."handle_types"(.CONTROL_RETURN)
-    push_eh $P811
+    new $P818, 'ExceptionHandler'
+    set_addr $P818, control_817
+    $P818."handle_types"(.CONTROL_RETURN)
+    push_eh $P818
     .lex "self", self
-    .lex "$/", param_812
+    .lex "$/", param_819
 .annotate 'line', 181
-    new $P813, "Undef"
-    .lex "$past", $P813
-    get_hll_global $P814, ["PAST"], "Regex"
-    find_lex $P815, "$/"
-    $P816 = $P814."new"("charclass" :named("pasttype"), "." :named("subtype"), $P815 :named("node"))
-    store_lex "$past", $P816
+    new $P820, "Undef"
+    .lex "$past", $P820
+    get_hll_global $P821, ["PAST"], "Regex"
+    find_lex $P822, "$/"
+    $P823 = $P821."new"("charclass" :named("pasttype"), "." :named("subtype"), $P822 :named("node"))
+    store_lex "$past", $P823
 .annotate 'line', 182
-    find_lex $P817, "$/"
-    find_lex $P818, "$past"
-    $P819 = $P817."!make"($P818)
+    find_lex $P824, "$/"
+    find_lex $P825, "$past"
+    $P826 = $P824."!make"($P825)
 .annotate 'line', 180
-    .return ($P819)
-  control_810:
+    .return ($P826)
+  control_817:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P820, exception, "payload"
-    .return ($P820)
+    getattribute $P827, exception, "payload"
+    .return ($P827)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<^>"  :subid("50_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_824
+.sub "metachar:sym<^>"  :subid("50_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_831
 .annotate 'line', 185
-    new $P823, 'ExceptionHandler'
-    set_addr $P823, control_822
-    $P823."handle_types"(.CONTROL_RETURN)
-    push_eh $P823
+    new $P830, 'ExceptionHandler'
+    set_addr $P830, control_829
+    $P830."handle_types"(.CONTROL_RETURN)
+    push_eh $P830
     .lex "self", self
-    .lex "$/", param_824
+    .lex "$/", param_831
 .annotate 'line', 186
-    new $P825, "Undef"
-    .lex "$past", $P825
-    get_hll_global $P826, ["PAST"], "Regex"
-    find_lex $P827, "$/"
-    $P828 = $P826."new"("anchor" :named("pasttype"), "bos" :named("subtype"), $P827 :named("node"))
-    store_lex "$past", $P828
+    new $P832, "Undef"
+    .lex "$past", $P832
+    get_hll_global $P833, ["PAST"], "Regex"
+    find_lex $P834, "$/"
+    $P835 = $P833."new"("anchor" :named("pasttype"), "bos" :named("subtype"), $P834 :named("node"))
+    store_lex "$past", $P835
 .annotate 'line', 187
-    find_lex $P829, "$/"
-    find_lex $P830, "$past"
-    $P831 = $P829."!make"($P830)
+    find_lex $P836, "$/"
+    find_lex $P837, "$past"
+    $P838 = $P836."!make"($P837)
 .annotate 'line', 185
-    .return ($P831)
-  control_822:
+    .return ($P838)
+  control_829:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P832, exception, "payload"
-    .return ($P832)
+    getattribute $P839, exception, "payload"
+    .return ($P839)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<^^>"  :subid("51_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_836
+.sub "metachar:sym<^^>"  :subid("51_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_843
 .annotate 'line', 190
-    new $P835, 'ExceptionHandler'
-    set_addr $P835, control_834
-    $P835."handle_types"(.CONTROL_RETURN)
-    push_eh $P835
+    new $P842, 'ExceptionHandler'
+    set_addr $P842, control_841
+    $P842."handle_types"(.CONTROL_RETURN)
+    push_eh $P842
     .lex "self", self
-    .lex "$/", param_836
+    .lex "$/", param_843
 .annotate 'line', 191
-    new $P837, "Undef"
-    .lex "$past", $P837
-    get_hll_global $P838, ["PAST"], "Regex"
-    find_lex $P839, "$/"
-    $P840 = $P838."new"("anchor" :named("pasttype"), "bol" :named("subtype"), $P839 :named("node"))
-    store_lex "$past", $P840
+    new $P844, "Undef"
+    .lex "$past", $P844
+    get_hll_global $P845, ["PAST"], "Regex"
+    find_lex $P846, "$/"
+    $P847 = $P845."new"("anchor" :named("pasttype"), "bol" :named("subtype"), $P846 :named("node"))
+    store_lex "$past", $P847
 .annotate 'line', 192
-    find_lex $P841, "$/"
-    find_lex $P842, "$past"
-    $P843 = $P841."!make"($P842)
+    find_lex $P848, "$/"
+    find_lex $P849, "$past"
+    $P850 = $P848."!make"($P849)
 .annotate 'line', 190
-    .return ($P843)
-  control_834:
+    .return ($P850)
+  control_841:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P844, exception, "payload"
-    .return ($P844)
+    getattribute $P851, exception, "payload"
+    .return ($P851)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<$>"  :subid("52_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_848
+.sub "metachar:sym<$>"  :subid("52_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_855
 .annotate 'line', 195
-    new $P847, 'ExceptionHandler'
-    set_addr $P847, control_846
-    $P847."handle_types"(.CONTROL_RETURN)
-    push_eh $P847
+    new $P854, 'ExceptionHandler'
+    set_addr $P854, control_853
+    $P854."handle_types"(.CONTROL_RETURN)
+    push_eh $P854
     .lex "self", self
-    .lex "$/", param_848
+    .lex "$/", param_855
 .annotate 'line', 196
-    new $P849, "Undef"
-    .lex "$past", $P849
-    get_hll_global $P850, ["PAST"], "Regex"
-    find_lex $P851, "$/"
-    $P852 = $P850."new"("anchor" :named("pasttype"), "eos" :named("subtype"), $P851 :named("node"))
-    store_lex "$past", $P852
+    new $P856, "Undef"
+    .lex "$past", $P856
+    get_hll_global $P857, ["PAST"], "Regex"
+    find_lex $P858, "$/"
+    $P859 = $P857."new"("anchor" :named("pasttype"), "eos" :named("subtype"), $P858 :named("node"))
+    store_lex "$past", $P859
 .annotate 'line', 197
-    find_lex $P853, "$/"
-    find_lex $P854, "$past"
-    $P855 = $P853."!make"($P854)
+    find_lex $P860, "$/"
+    find_lex $P861, "$past"
+    $P862 = $P860."!make"($P861)
 .annotate 'line', 195
-    .return ($P855)
-  control_846:
+    .return ($P862)
+  control_853:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P856, exception, "payload"
-    .return ($P856)
+    getattribute $P863, exception, "payload"
+    .return ($P863)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<$$>"  :subid("53_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_860
+.sub "metachar:sym<$$>"  :subid("53_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_867
 .annotate 'line', 200
-    new $P859, 'ExceptionHandler'
-    set_addr $P859, control_858
-    $P859."handle_types"(.CONTROL_RETURN)
-    push_eh $P859
+    new $P866, 'ExceptionHandler'
+    set_addr $P866, control_865
+    $P866."handle_types"(.CONTROL_RETURN)
+    push_eh $P866
     .lex "self", self
-    .lex "$/", param_860
+    .lex "$/", param_867
 .annotate 'line', 201
-    new $P861, "Undef"
-    .lex "$past", $P861
-    get_hll_global $P862, ["PAST"], "Regex"
-    find_lex $P863, "$/"
-    $P864 = $P862."new"("anchor" :named("pasttype"), "eol" :named("subtype"), $P863 :named("node"))
-    store_lex "$past", $P864
+    new $P868, "Undef"
+    .lex "$past", $P868
+    get_hll_global $P869, ["PAST"], "Regex"
+    find_lex $P870, "$/"
+    $P871 = $P869."new"("anchor" :named("pasttype"), "eol" :named("subtype"), $P870 :named("node"))
+    store_lex "$past", $P871
 .annotate 'line', 202
-    find_lex $P865, "$/"
-    find_lex $P866, "$past"
-    $P867 = $P865."!make"($P866)
+    find_lex $P872, "$/"
+    find_lex $P873, "$past"
+    $P874 = $P872."!make"($P873)
 .annotate 'line', 200
-    .return ($P867)
-  control_858:
+    .return ($P874)
+  control_865:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P868, exception, "payload"
-    .return ($P868)
+    getattribute $P875, exception, "payload"
+    .return ($P875)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<:::>"  :subid("54_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_872
+.sub "metachar:sym<:::>"  :subid("54_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_879
 .annotate 'line', 205
-    new $P871, 'ExceptionHandler'
-    set_addr $P871, control_870
-    $P871."handle_types"(.CONTROL_RETURN)
-    push_eh $P871
+    new $P878, 'ExceptionHandler'
+    set_addr $P878, control_877
+    $P878."handle_types"(.CONTROL_RETURN)
+    push_eh $P878
     .lex "self", self
-    .lex "$/", param_872
+    .lex "$/", param_879
 .annotate 'line', 206
-    new $P873, "Undef"
-    .lex "$past", $P873
-    get_hll_global $P874, ["PAST"], "Regex"
-    find_lex $P875, "$/"
-    $P876 = $P874."new"("cut" :named("pasttype"), $P875 :named("node"))
-    store_lex "$past", $P876
+    new $P880, "Undef"
+    .lex "$past", $P880
+    get_hll_global $P881, ["PAST"], "Regex"
+    find_lex $P882, "$/"
+    $P883 = $P881."new"("cut" :named("pasttype"), $P882 :named("node"))
+    store_lex "$past", $P883
 .annotate 'line', 207
-    find_lex $P877, "$/"
-    find_lex $P878, "$past"
-    $P879 = $P877."!make"($P878)
+    find_lex $P884, "$/"
+    find_lex $P885, "$past"
+    $P886 = $P884."!make"($P885)
 .annotate 'line', 205
-    .return ($P879)
-  control_870:
+    .return ($P886)
+  control_877:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P880, exception, "payload"
-    .return ($P880)
+    getattribute $P887, exception, "payload"
+    .return ($P887)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<lwb>"  :subid("55_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_884
+.sub "metachar:sym<lwb>"  :subid("55_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_891
 .annotate 'line', 210
-    new $P883, 'ExceptionHandler'
-    set_addr $P883, control_882
-    $P883."handle_types"(.CONTROL_RETURN)
-    push_eh $P883
+    new $P890, 'ExceptionHandler'
+    set_addr $P890, control_889
+    $P890."handle_types"(.CONTROL_RETURN)
+    push_eh $P890
     .lex "self", self
-    .lex "$/", param_884
+    .lex "$/", param_891
 .annotate 'line', 211
-    new $P885, "Undef"
-    .lex "$past", $P885
-    get_hll_global $P886, ["PAST"], "Regex"
-    find_lex $P887, "$/"
-    $P888 = $P886."new"("anchor" :named("pasttype"), "lwb" :named("subtype"), $P887 :named("node"))
-    store_lex "$past", $P888
+    new $P892, "Undef"
+    .lex "$past", $P892
+    get_hll_global $P893, ["PAST"], "Regex"
+    find_lex $P894, "$/"
+    $P895 = $P893."new"("anchor" :named("pasttype"), "lwb" :named("subtype"), $P894 :named("node"))
+    store_lex "$past", $P895
 .annotate 'line', 212
-    find_lex $P889, "$/"
-    find_lex $P890, "$past"
-    $P891 = $P889."!make"($P890)
+    find_lex $P896, "$/"
+    find_lex $P897, "$past"
+    $P898 = $P896."!make"($P897)
 .annotate 'line', 210
-    .return ($P891)
-  control_882:
+    .return ($P898)
+  control_889:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P892, exception, "payload"
-    .return ($P892)
+    getattribute $P899, exception, "payload"
+    .return ($P899)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<rwb>"  :subid("56_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_896
+.sub "metachar:sym<rwb>"  :subid("56_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_903
 .annotate 'line', 215
-    new $P895, 'ExceptionHandler'
-    set_addr $P895, control_894
-    $P895."handle_types"(.CONTROL_RETURN)
-    push_eh $P895
+    new $P902, 'ExceptionHandler'
+    set_addr $P902, control_901
+    $P902."handle_types"(.CONTROL_RETURN)
+    push_eh $P902
     .lex "self", self
-    .lex "$/", param_896
+    .lex "$/", param_903
 .annotate 'line', 216
-    new $P897, "Undef"
-    .lex "$past", $P897
-    get_hll_global $P898, ["PAST"], "Regex"
-    find_lex $P899, "$/"
-    $P900 = $P898."new"("anchor" :named("pasttype"), "rwb" :named("subtype"), $P899 :named("node"))
-    store_lex "$past", $P900
+    new $P904, "Undef"
+    .lex "$past", $P904
+    get_hll_global $P905, ["PAST"], "Regex"
+    find_lex $P906, "$/"
+    $P907 = $P905."new"("anchor" :named("pasttype"), "rwb" :named("subtype"), $P906 :named("node"))
+    store_lex "$past", $P907
 .annotate 'line', 217
-    find_lex $P901, "$/"
-    find_lex $P902, "$past"
-    $P903 = $P901."!make"($P902)
+    find_lex $P908, "$/"
+    find_lex $P909, "$past"
+    $P910 = $P908."!make"($P909)
 .annotate 'line', 215
-    .return ($P903)
-  control_894:
+    .return ($P910)
+  control_901:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P904, exception, "payload"
-    .return ($P904)
+    getattribute $P911, exception, "payload"
+    .return ($P911)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<bs>"  :subid("57_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_908
+.sub "metachar:sym<bs>"  :subid("57_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_915
 .annotate 'line', 220
-    new $P907, 'ExceptionHandler'
-    set_addr $P907, control_906
-    $P907."handle_types"(.CONTROL_RETURN)
-    push_eh $P907
+    new $P914, 'ExceptionHandler'
+    set_addr $P914, control_913
+    $P914."handle_types"(.CONTROL_RETURN)
+    push_eh $P914
     .lex "self", self
-    .lex "$/", param_908
+    .lex "$/", param_915
 .annotate 'line', 221
-    find_lex $P909, "$/"
-    find_lex $P910, "$/"
-    unless_null $P910, vivify_235
-    $P910 = root_new ['parrot';'Hash']
-  vivify_235:
-    set $P911, $P910["backslash"]
-    unless_null $P911, vivify_236
-    new $P911, "Undef"
-  vivify_236:
-    $P912 = $P911."ast"()
-    $P913 = $P909."!make"($P912)
+    find_lex $P916, "$/"
+    find_lex $P917, "$/"
+    unless_null $P917, vivify_239
+    $P917 = root_new ['parrot';'Hash']
+  vivify_239:
+    set $P918, $P917["backslash"]
+    unless_null $P918, vivify_240
+    new $P918, "Undef"
+  vivify_240:
+    $P919 = $P918."ast"()
+    $P920 = $P916."!make"($P919)
 .annotate 'line', 220
-    .return ($P913)
-  control_906:
+    .return ($P920)
+  control_913:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P914, exception, "payload"
-    .return ($P914)
+    getattribute $P921, exception, "payload"
+    .return ($P921)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<mod>"  :subid("58_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_918
+.sub "metachar:sym<mod>"  :subid("58_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_925
 .annotate 'line', 224
-    new $P917, 'ExceptionHandler'
-    set_addr $P917, control_916
-    $P917."handle_types"(.CONTROL_RETURN)
-    push_eh $P917
+    new $P924, 'ExceptionHandler'
+    set_addr $P924, control_923
+    $P924."handle_types"(.CONTROL_RETURN)
+    push_eh $P924
     .lex "self", self
-    .lex "$/", param_918
+    .lex "$/", param_925
 .annotate 'line', 225
-    find_lex $P919, "$/"
-    find_lex $P920, "$/"
-    unless_null $P920, vivify_237
-    $P920 = root_new ['parrot';'Hash']
-  vivify_237:
-    set $P921, $P920["mod_internal"]
-    unless_null $P921, vivify_238
-    new $P921, "Undef"
-  vivify_238:
-    $P922 = $P921."ast"()
-    $P923 = $P919."!make"($P922)
+    find_lex $P926, "$/"
+    find_lex $P927, "$/"
+    unless_null $P927, vivify_241
+    $P927 = root_new ['parrot';'Hash']
+  vivify_241:
+    set $P928, $P927["mod_internal"]
+    unless_null $P928, vivify_242
+    new $P928, "Undef"
+  vivify_242:
+    $P929 = $P928."ast"()
+    $P930 = $P926."!make"($P929)
 .annotate 'line', 224
-    .return ($P923)
-  control_916:
+    .return ($P930)
+  control_923:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P924, exception, "payload"
-    .return ($P924)
+    getattribute $P931, exception, "payload"
+    .return ($P931)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<assert>"  :subid("59_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_928
+.sub "metachar:sym<assert>"  :subid("59_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_935
 .annotate 'line', 228
-    new $P927, 'ExceptionHandler'
-    set_addr $P927, control_926
-    $P927."handle_types"(.CONTROL_RETURN)
-    push_eh $P927
+    new $P934, 'ExceptionHandler'
+    set_addr $P934, control_933
+    $P934."handle_types"(.CONTROL_RETURN)
+    push_eh $P934
     .lex "self", self
-    .lex "$/", param_928
+    .lex "$/", param_935
 .annotate 'line', 229
-    find_lex $P929, "$/"
-    find_lex $P930, "$/"
-    unless_null $P930, vivify_239
-    $P930 = root_new ['parrot';'Hash']
-  vivify_239:
-    set $P931, $P930["assertion"]
-    unless_null $P931, vivify_240
-    new $P931, "Undef"
-  vivify_240:
-    $P932 = $P931."ast"()
-    $P933 = $P929."!make"($P932)
+    find_lex $P936, "$/"
+    find_lex $P937, "$/"
+    unless_null $P937, vivify_243
+    $P937 = root_new ['parrot';'Hash']
+  vivify_243:
+    set $P938, $P937["assertion"]
+    unless_null $P938, vivify_244
+    new $P938, "Undef"
+  vivify_244:
+    $P939 = $P938."ast"()
+    $P940 = $P936."!make"($P939)
 .annotate 'line', 228
-    .return ($P933)
-  control_926:
+    .return ($P940)
+  control_933:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P934, exception, "payload"
-    .return ($P934)
+    getattribute $P941, exception, "payload"
+    .return ($P941)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<~>"  :subid("60_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_938
+.sub "metachar:sym<~>"  :subid("60_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_945
 .annotate 'line', 232
-    new $P937, 'ExceptionHandler'
-    set_addr $P937, control_936
-    $P937."handle_types"(.CONTROL_RETURN)
-    push_eh $P937
+    new $P944, 'ExceptionHandler'
+    set_addr $P944, control_943
+    $P944."handle_types"(.CONTROL_RETURN)
+    push_eh $P944
     .lex "self", self
-    .lex "$/", param_938
+    .lex "$/", param_945
 .annotate 'line', 233
-    find_lex $P939, "$/"
-    get_hll_global $P940, ["PAST"], "Regex"
+    find_lex $P946, "$/"
+    get_hll_global $P947, ["PAST"], "Regex"
 .annotate 'line', 234
-    find_lex $P941, "$/"
-    unless_null $P941, vivify_241
-    $P941 = root_new ['parrot';'Hash']
-  vivify_241:
-    set $P942, $P941["EXPR"]
-    unless_null $P942, vivify_242
-    new $P942, "Undef"
-  vivify_242:
-    $P943 = $P942."ast"()
+    find_lex $P948, "$/"
+    unless_null $P948, vivify_245
+    $P948 = root_new ['parrot';'Hash']
+  vivify_245:
+    set $P949, $P948["EXPR"]
+    unless_null $P949, vivify_246
+    new $P949, "Undef"
+  vivify_246:
+    $P950 = $P949."ast"()
 .annotate 'line', 235
-    get_hll_global $P944, ["PAST"], "Regex"
+    get_hll_global $P951, ["PAST"], "Regex"
 .annotate 'line', 236
-    find_lex $P945, "$/"
-    unless_null $P945, vivify_243
-    $P945 = root_new ['parrot';'Hash']
-  vivify_243:
-    set $P946, $P945["GOAL"]
-    unless_null $P946, vivify_244
-    new $P946, "Undef"
-  vivify_244:
-    $P947 = $P946."ast"()
+    find_lex $P952, "$/"
+    unless_null $P952, vivify_247
+    $P952 = root_new ['parrot';'Hash']
+  vivify_247:
+    set $P953, $P952["GOAL"]
+    unless_null $P953, vivify_248
+    new $P953, "Undef"
+  vivify_248:
+    $P954 = $P953."ast"()
 .annotate 'line', 237
-    get_hll_global $P948, ["PAST"], "Regex"
-    find_lex $P949, "$/"
-    unless_null $P949, vivify_245
-    $P949 = root_new ['parrot';'Hash']
-  vivify_245:
-    set $P950, $P949["GOAL"]
-    unless_null $P950, vivify_246
-    new $P950, "Undef"
-  vivify_246:
-    set $S951, $P950
-    $P952 = $P948."new"("FAILGOAL", $S951, "subrule" :named("pasttype"), "method" :named("subtype"))
-    $P953 = $P944."new"($P947, $P952, "alt" :named("pasttype"))
+    get_hll_global $P955, ["PAST"], "Regex"
+    find_lex $P956, "$/"
+    unless_null $P956, vivify_249
+    $P956 = root_new ['parrot';'Hash']
+  vivify_249:
+    set $P957, $P956["GOAL"]
+    unless_null $P957, vivify_250
+    new $P957, "Undef"
+  vivify_250:
+    set $S958, $P957
+    $P959 = $P955."new"("FAILGOAL", $S958, "subrule" :named("pasttype"), "method" :named("subtype"))
+    $P960 = $P951."new"($P954, $P959, "alt" :named("pasttype"))
 .annotate 'line', 235
-    $P954 = $P940."new"($P943, $P953, "concat" :named("pasttype"))
+    $P961 = $P947."new"($P950, $P960, "concat" :named("pasttype"))
 .annotate 'line', 233
-    $P955 = $P939."!make"($P954)
+    $P962 = $P946."!make"($P961)
 .annotate 'line', 232
-    .return ($P955)
-  control_936:
+    .return ($P962)
+  control_943:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P956, exception, "payload"
-    .return ($P956)
+    getattribute $P963, exception, "payload"
+    .return ($P963)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<{*}>"  :subid("61_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_960
+.sub "metachar:sym<{*}>"  :subid("61_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_967
 .annotate 'line', 245
-    new $P959, 'ExceptionHandler'
-    set_addr $P959, control_958
-    $P959."handle_types"(.CONTROL_RETURN)
-    push_eh $P959
+    new $P966, 'ExceptionHandler'
+    set_addr $P966, control_965
+    $P966."handle_types"(.CONTROL_RETURN)
+    push_eh $P966
     .lex "self", self
-    .lex "$/", param_960
+    .lex "$/", param_967
 .annotate 'line', 246
-    new $P961, "Undef"
-    .lex "$past", $P961
+    new $P968, "Undef"
+    .lex "$past", $P968
 .annotate 'line', 247
-    find_lex $P964, "$/"
-    unless_null $P964, vivify_247
-    $P964 = root_new ['parrot';'Hash']
-  vivify_247:
-    set $P965, $P964["key"]
-    unless_null $P965, vivify_248
-    new $P965, "Undef"
-  vivify_248:
-    if $P965, if_963
-    new $P973, "Integer"
-    assign $P973, 0
-    set $P962, $P973
-    goto if_963_end
-  if_963:
-    get_hll_global $P966, ["PAST"], "Regex"
-    find_lex $P967, "$/"
-    unless_null $P967, vivify_249
-    $P967 = root_new ['parrot';'Hash']
-  vivify_249:
-    set $P968, $P967["key"]
-    unless_null $P968, vivify_250
-    $P968 = root_new ['parrot';'ResizablePMCArray']
-  vivify_250:
-    set $P969, $P968[0]
-    unless_null $P969, vivify_251
-    new $P969, "Undef"
-  vivify_251:
-    set $S970, $P969
     find_lex $P971, "$/"
-    $P972 = $P966."new"($S970, "reduce" :named("pasttype"), $P971 :named("node"))
-    set $P962, $P972
-  if_963_end:
-    store_lex "$past", $P962
-.annotate 'line', 249
+    unless_null $P971, vivify_251
+    $P971 = root_new ['parrot';'Hash']
+  vivify_251:
+    set $P972, $P971["key"]
+    unless_null $P972, vivify_252
+    new $P972, "Undef"
+  vivify_252:
+    if $P972, if_970
+    new $P980, "Integer"
+    assign $P980, 0
+    set $P969, $P980
+    goto if_970_end
+  if_970:
+    get_hll_global $P973, ["PAST"], "Regex"
     find_lex $P974, "$/"
-    find_lex $P975, "$past"
-    $P976 = $P974."!make"($P975)
+    unless_null $P974, vivify_253
+    $P974 = root_new ['parrot';'Hash']
+  vivify_253:
+    set $P975, $P974["key"]
+    unless_null $P975, vivify_254
+    $P975 = root_new ['parrot';'ResizablePMCArray']
+  vivify_254:
+    set $P976, $P975[0]
+    unless_null $P976, vivify_255
+    new $P976, "Undef"
+  vivify_255:
+    set $S977, $P976
+    find_lex $P978, "$/"
+    $P979 = $P973."new"($S977, "reduce" :named("pasttype"), $P978 :named("node"))
+    set $P969, $P979
+  if_970_end:
+    store_lex "$past", $P969
+.annotate 'line', 249
+    find_lex $P981, "$/"
+    find_lex $P982, "$past"
+    $P983 = $P981."!make"($P982)
 .annotate 'line', 245
-    .return ($P976)
-  control_958:
+    .return ($P983)
+  control_965:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P977, exception, "payload"
-    .return ($P977)
+    getattribute $P984, exception, "payload"
+    .return ($P984)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<var>"  :subid("62_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_981
+.sub "metachar:sym<var>"  :subid("62_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_988
 .annotate 'line', 252
-    new $P980, 'ExceptionHandler'
-    set_addr $P980, control_979
-    $P980."handle_types"(.CONTROL_RETURN)
-    push_eh $P980
+    new $P987, 'ExceptionHandler'
+    set_addr $P987, control_986
+    $P987."handle_types"(.CONTROL_RETURN)
+    push_eh $P987
     .lex "self", self
-    .lex "$/", param_981
+    .lex "$/", param_988
 .annotate 'line', 253
-    new $P982, "Undef"
-    .lex "$past", $P982
+    new $P989, "Undef"
+    .lex "$past", $P989
 .annotate 'line', 254
-    new $P983, "Undef"
-    .lex "$name", $P983
+    new $P990, "Undef"
+    .lex "$name", $P990
 .annotate 'line', 252
-    find_lex $P984, "$past"
+    find_lex $P991, "$past"
 .annotate 'line', 254
-    find_lex $P987, "$/"
-    unless_null $P987, vivify_252
-    $P987 = root_new ['parrot';'Hash']
-  vivify_252:
-    set $P988, $P987["pos"]
-    unless_null $P988, vivify_253
-    new $P988, "Undef"
-  vivify_253:
-    if $P988, if_986
-    find_lex $P992, "$/"
-    unless_null $P992, vivify_254
-    $P992 = root_new ['parrot';'Hash']
-  vivify_254:
-    set $P993, $P992["name"]
-    unless_null $P993, vivify_255
-    new $P993, "Undef"
-  vivify_255:
-    set $S994, $P993
-    new $P985, 'String'
-    set $P985, $S994
-    goto if_986_end
-  if_986:
-    find_lex $P989, "$/"
-    unless_null $P989, vivify_256
-    $P989 = root_new ['parrot';'Hash']
+    find_lex $P994, "$/"
+    unless_null $P994, vivify_256
+    $P994 = root_new ['parrot';'Hash']
   vivify_256:
-    set $P990, $P989["pos"]
-    unless_null $P990, vivify_257
-    new $P990, "Undef"
+    set $P995, $P994["pos"]
+    unless_null $P995, vivify_257
+    new $P995, "Undef"
   vivify_257:
-    set $N991, $P990
-    new $P985, 'Float'
-    set $P985, $N991
-  if_986_end:
-    store_lex "$name", $P985
-.annotate 'line', 255
-    find_lex $P996, "$/"
-    unless_null $P996, vivify_258
-    $P996 = root_new ['parrot';'Hash']
+    if $P995, if_993
+    find_lex $P999, "$/"
+    unless_null $P999, vivify_258
+    $P999 = root_new ['parrot';'Hash']
   vivify_258:
-    set $P997, $P996["quantified_atom"]
-    unless_null $P997, vivify_259
-    new $P997, "Undef"
+    set $P1000, $P999["name"]
+    unless_null $P1000, vivify_259
+    new $P1000, "Undef"
   vivify_259:
-    if $P997, if_995
-.annotate 'line', 266
-    get_hll_global $P1028, ["PAST"], "Regex"
-    find_lex $P1029, "$name"
-    find_lex $P1030, "$/"
-    $P1031 = $P1028."new"("!BACKREF", $P1029, "subrule" :named("pasttype"), "method" :named("subtype"), $P1030 :named("node"))
-    store_lex "$past", $P1031
-.annotate 'line', 265
-    goto if_995_end
-  if_995:
-.annotate 'line', 256
-    find_lex $P998, "$/"
-    unless_null $P998, vivify_260
-    $P998 = root_new ['parrot';'Hash']
+    set $S1001, $P1000
+    new $P992, 'String'
+    set $P992, $S1001
+    goto if_993_end
+  if_993:
+    find_lex $P996, "$/"
+    unless_null $P996, vivify_260
+    $P996 = root_new ['parrot';'Hash']
   vivify_260:
-    set $P999, $P998["quantified_atom"]
-    unless_null $P999, vivify_261
-    $P999 = root_new ['parrot';'ResizablePMCArray']
+    set $P997, $P996["pos"]
+    unless_null $P997, vivify_261
+    new $P997, "Undef"
   vivify_261:
-    set $P1000, $P999[0]
-    unless_null $P1000, vivify_262
-    new $P1000, "Undef"
+    set $N998, $P997
+    new $P992, 'Float'
+    set $P992, $N998
+  if_993_end:
+    store_lex "$name", $P992
+.annotate 'line', 255
+    find_lex $P1003, "$/"
+    unless_null $P1003, vivify_262
+    $P1003 = root_new ['parrot';'Hash']
   vivify_262:
-    $P1001 = $P1000."ast"()
-    store_lex "$past", $P1001
-.annotate 'line', 257
-    find_lex $P1005, "$past"
-    $S1006 = $P1005."pasttype"()
-    iseq $I1007, $S1006, "quant"
-    if $I1007, if_1004
-    new $P1003, 'Integer'
-    set $P1003, $I1007
-    goto if_1004_end
-  if_1004:
-    find_lex $P1008, "$past"
-    unless_null $P1008, vivify_263
-    $P1008 = root_new ['parrot';'ResizablePMCArray']
+    set $P1004, $P1003["quantified_atom"]
+    unless_null $P1004, vivify_263
+    new $P1004, "Undef"
   vivify_263:
-    set $P1009, $P1008[0]
-    unless_null $P1009, vivify_264
-    new $P1009, "Undef"
+    if $P1004, if_1002
+.annotate 'line', 266
+    get_hll_global $P1035, ["PAST"], "Regex"
+    find_lex $P1036, "$name"
+    find_lex $P1037, "$/"
+    $P1038 = $P1035."new"("!BACKREF", $P1036, "subrule" :named("pasttype"), "method" :named("subtype"), $P1037 :named("node"))
+    store_lex "$past", $P1038
+.annotate 'line', 265
+    goto if_1002_end
+  if_1002:
+.annotate 'line', 256
+    find_lex $P1005, "$/"
+    unless_null $P1005, vivify_264
+    $P1005 = root_new ['parrot';'Hash']
   vivify_264:
-    $S1010 = $P1009."pasttype"()
-    iseq $I1011, $S1010, "subrule"
-    new $P1003, 'Integer'
-    set $P1003, $I1011
-  if_1004_end:
-    if $P1003, if_1002
+    set $P1006, $P1005["quantified_atom"]
+    unless_null $P1006, vivify_265
+    $P1006 = root_new ['parrot';'ResizablePMCArray']
+  vivify_265:
+    set $P1007, $P1006[0]
+    unless_null $P1007, vivify_266
+    new $P1007, "Undef"
+  vivify_266:
+    $P1008 = $P1007."ast"()
+    store_lex "$past", $P1008
+.annotate 'line', 257
+    find_lex $P1012, "$past"
+    $S1013 = $P1012."pasttype"()
+    iseq $I1014, $S1013, "quant"
+    if $I1014, if_1011
+    new $P1010, 'Integer'
+    set $P1010, $I1014
+    goto if_1011_end
+  if_1011:
+    find_lex $P1015, "$past"
+    unless_null $P1015, vivify_267
+    $P1015 = root_new ['parrot';'ResizablePMCArray']
+  vivify_267:
+    set $P1016, $P1015[0]
+    unless_null $P1016, vivify_268
+    new $P1016, "Undef"
+  vivify_268:
+    $S1017 = $P1016."pasttype"()
+    iseq $I1018, $S1017, "subrule"
+    new $P1010, 'Integer'
+    set $P1010, $I1018
+  if_1011_end:
+    if $P1010, if_1009
 .annotate 'line', 260
-    find_lex $P1017, "$past"
-    $S1018 = $P1017."pasttype"()
-    iseq $I1019, $S1018, "subrule"
-    if $I1019, if_1016
-.annotate 'line', 262
-    get_hll_global $P1023, ["PAST"], "Regex"
     find_lex $P1024, "$past"
-    find_lex $P1025, "$name"
-    find_lex $P1026, "$/"
-    $P1027 = $P1023."new"($P1024, $P1025 :named("name"), "subcapture" :named("pasttype"), $P1026 :named("node"))
-    store_lex "$past", $P1027
+    $S1025 = $P1024."pasttype"()
+    iseq $I1026, $S1025, "subrule"
+    if $I1026, if_1023
+.annotate 'line', 262
+    get_hll_global $P1030, ["PAST"], "Regex"
+    find_lex $P1031, "$past"
+    find_lex $P1032, "$name"
+    find_lex $P1033, "$/"
+    $P1034 = $P1030."new"($P1031, $P1032 :named("name"), "subcapture" :named("pasttype"), $P1033 :named("node"))
+    store_lex "$past", $P1034
 .annotate 'line', 261
-    goto if_1016_end
-  if_1016:
+    goto if_1023_end
+  if_1023:
 .annotate 'line', 260
-    find_lex $P1020, "self"
-    find_lex $P1021, "$past"
-    find_lex $P1022, "$name"
-    $P1020."subrule_alias"($P1021, $P1022)
-  if_1016_end:
-    goto if_1002_end
-  if_1002:
+    find_lex $P1027, "self"
+    find_lex $P1028, "$past"
+    find_lex $P1029, "$name"
+    $P1027."subrule_alias"($P1028, $P1029)
+  if_1023_end:
+    goto if_1009_end
+  if_1009:
 .annotate 'line', 258
-    find_lex $P1012, "self"
-    find_lex $P1013, "$past"
-    unless_null $P1013, vivify_265
-    $P1013 = root_new ['parrot';'ResizablePMCArray']
-  vivify_265:
-    set $P1014, $P1013[0]
-    unless_null $P1014, vivify_266
-    new $P1014, "Undef"
-  vivify_266:
-    find_lex $P1015, "$name"
-    $P1012."subrule_alias"($P1014, $P1015)
+    find_lex $P1019, "self"
+    find_lex $P1020, "$past"
+    unless_null $P1020, vivify_269
+    $P1020 = root_new ['parrot';'ResizablePMCArray']
+  vivify_269:
+    set $P1021, $P1020[0]
+    unless_null $P1021, vivify_270
+    new $P1021, "Undef"
+  vivify_270:
+    find_lex $P1022, "$name"
+    $P1019."subrule_alias"($P1021, $P1022)
+  if_1009_end:
   if_1002_end:
-  if_995_end:
 .annotate 'line', 269
-    find_lex $P1032, "$/"
-    find_lex $P1033, "$past"
-    $P1034 = $P1032."!make"($P1033)
+    find_lex $P1039, "$/"
+    find_lex $P1040, "$past"
+    $P1041 = $P1039."!make"($P1040)
 .annotate 'line', 252
-    .return ($P1034)
-  control_979:
+    .return ($P1041)
+  control_986:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1035, exception, "payload"
-    .return ($P1035)
+    getattribute $P1042, exception, "payload"
+    .return ($P1042)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "metachar:sym<PIR>"  :subid("63_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1039
+.sub "metachar:sym<PIR>"  :subid("63_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1046
 .annotate 'line', 272
-    new $P1038, 'ExceptionHandler'
-    set_addr $P1038, control_1037
-    $P1038."handle_types"(.CONTROL_RETURN)
-    push_eh $P1038
+    new $P1045, 'ExceptionHandler'
+    set_addr $P1045, control_1044
+    $P1045."handle_types"(.CONTROL_RETURN)
+    push_eh $P1045
     .lex "self", self
-    .lex "$/", param_1039
+    .lex "$/", param_1046
 .annotate 'line', 273
-    find_lex $P1040, "$/"
-    get_hll_global $P1041, ["PAST"], "Regex"
-.annotate 'line', 274
-    get_hll_global $P1042, ["PAST"], "Op"
-    find_lex $P1043, "$/"
-    unless_null $P1043, vivify_267
-    $P1043 = root_new ['parrot';'Hash']
-  vivify_267:
-    set $P1044, $P1043["pir"]
-    unless_null $P1044, vivify_268
-    new $P1044, "Undef"
-  vivify_268:
-    set $S1045, $P1044
-    $P1046 = $P1042."new"($S1045 :named("inline"), "inline" :named("pasttype"))
     find_lex $P1047, "$/"
-    $P1048 = $P1041."new"($P1046, "pastnode" :named("pasttype"), $P1047 :named("node"))
+    get_hll_global $P1048, ["PAST"], "Regex"
+.annotate 'line', 274
+    get_hll_global $P1049, ["PAST"], "Op"
+    find_lex $P1050, "$/"
+    unless_null $P1050, vivify_271
+    $P1050 = root_new ['parrot';'Hash']
+  vivify_271:
+    set $P1051, $P1050["pir"]
+    unless_null $P1051, vivify_272
+    new $P1051, "Undef"
+  vivify_272:
+    set $S1052, $P1051
+    $P1053 = $P1049."new"($S1052 :named("inline"), "inline" :named("pasttype"))
+    find_lex $P1054, "$/"
+    $P1055 = $P1048."new"($P1053, "pastnode" :named("pasttype"), $P1054 :named("node"))
 .annotate 'line', 273
-    $P1049 = $P1040."!make"($P1048)
+    $P1056 = $P1047."!make"($P1055)
 .annotate 'line', 272
-    .return ($P1049)
-  control_1037:
+    .return ($P1056)
+  control_1044:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1050, exception, "payload"
-    .return ($P1050)
+    getattribute $P1057, exception, "payload"
+    .return ($P1057)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<w>"  :subid("64_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1054
+.sub "backslash:sym<w>"  :subid("64_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1061
 .annotate 'line', 280
-    new $P1053, 'ExceptionHandler'
-    set_addr $P1053, control_1052
-    $P1053."handle_types"(.CONTROL_RETURN)
-    push_eh $P1053
+    new $P1060, 'ExceptionHandler'
+    set_addr $P1060, control_1059
+    $P1060."handle_types"(.CONTROL_RETURN)
+    push_eh $P1060
     .lex "self", self
-    .lex "$/", param_1054
+    .lex "$/", param_1061
 .annotate 'line', 281
-    new $P1055, "Undef"
-    .lex "$subtype", $P1055
+    new $P1062, "Undef"
+    .lex "$subtype", $P1062
 .annotate 'line', 282
-    new $P1056, "Undef"
-    .lex "$past", $P1056
+    new $P1063, "Undef"
+    .lex "$past", $P1063
 .annotate 'line', 281
-    find_lex $P1059, "$/"
-    unless_null $P1059, vivify_269
-    $P1059 = root_new ['parrot';'Hash']
-  vivify_269:
-    set $P1060, $P1059["sym"]
-    unless_null $P1060, vivify_270
-    new $P1060, "Undef"
-  vivify_270:
-    set $S1061, $P1060
-    iseq $I1062, $S1061, "n"
-    if $I1062, if_1058
-    find_lex $P1064, "$/"
-    unless_null $P1064, vivify_271
-    $P1064 = root_new ['parrot';'Hash']
-  vivify_271:
-    set $P1065, $P1064["sym"]
-    unless_null $P1065, vivify_272
-    new $P1065, "Undef"
-  vivify_272:
-    set $S1066, $P1065
-    new $P1057, 'String'
-    set $P1057, $S1066
-    goto if_1058_end
-  if_1058:
-    new $P1063, "String"
-    assign $P1063, "nl"
-    set $P1057, $P1063
-  if_1058_end:
-    store_lex "$subtype", $P1057
+    find_lex $P1066, "$/"
+    unless_null $P1066, vivify_273
+    $P1066 = root_new ['parrot';'Hash']
+  vivify_273:
+    set $P1067, $P1066["sym"]
+    unless_null $P1067, vivify_274
+    new $P1067, "Undef"
+  vivify_274:
+    set $S1068, $P1067
+    iseq $I1069, $S1068, "n"
+    if $I1069, if_1065
+    find_lex $P1071, "$/"
+    unless_null $P1071, vivify_275
+    $P1071 = root_new ['parrot';'Hash']
+  vivify_275:
+    set $P1072, $P1071["sym"]
+    unless_null $P1072, vivify_276
+    new $P1072, "Undef"
+  vivify_276:
+    set $S1073, $P1072
+    new $P1064, 'String'
+    set $P1064, $S1073
+    goto if_1065_end
+  if_1065:
+    new $P1070, "String"
+    assign $P1070, "nl"
+    set $P1064, $P1070
+  if_1065_end:
+    store_lex "$subtype", $P1064
 .annotate 'line', 282
-    get_hll_global $P1067, ["PAST"], "Regex"
-    find_lex $P1068, "$subtype"
-    find_lex $P1069, "$/"
-    $P1070 = $P1067."new"("charclass" :named("pasttype"), $P1068 :named("subtype"), $P1069 :named("node"))
-    store_lex "$past", $P1070
+    get_hll_global $P1074, ["PAST"], "Regex"
+    find_lex $P1075, "$subtype"
+    find_lex $P1076, "$/"
+    $P1077 = $P1074."new"("charclass" :named("pasttype"), $P1075 :named("subtype"), $P1076 :named("node"))
+    store_lex "$past", $P1077
 .annotate 'line', 283
-    find_lex $P1071, "$/"
-    find_lex $P1072, "$past"
-    $P1073 = $P1071."!make"($P1072)
+    find_lex $P1078, "$/"
+    find_lex $P1079, "$past"
+    $P1080 = $P1078."!make"($P1079)
 .annotate 'line', 280
-    .return ($P1073)
-  control_1052:
+    .return ($P1080)
+  control_1059:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1074, exception, "payload"
-    .return ($P1074)
+    getattribute $P1081, exception, "payload"
+    .return ($P1081)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<b>"  :subid("65_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1078
+.sub "backslash:sym<b>"  :subid("65_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1085
 .annotate 'line', 286
-    new $P1077, 'ExceptionHandler'
-    set_addr $P1077, control_1076
-    $P1077."handle_types"(.CONTROL_RETURN)
-    push_eh $P1077
+    new $P1084, 'ExceptionHandler'
+    set_addr $P1084, control_1083
+    $P1084."handle_types"(.CONTROL_RETURN)
+    push_eh $P1084
     .lex "self", self
-    .lex "$/", param_1078
+    .lex "$/", param_1085
 .annotate 'line', 287
-    new $P1079, "Undef"
-    .lex "$past", $P1079
-    get_hll_global $P1080, ["PAST"], "Regex"
+    new $P1086, "Undef"
+    .lex "$past", $P1086
+    get_hll_global $P1087, ["PAST"], "Regex"
 .annotate 'line', 288
-    find_lex $P1081, "$/"
-    unless_null $P1081, vivify_273
-    $P1081 = root_new ['parrot';'Hash']
-  vivify_273:
-    set $P1082, $P1081["sym"]
-    unless_null $P1082, vivify_274
-    new $P1082, "Undef"
-  vivify_274:
-    set $S1083, $P1082
-    iseq $I1084, $S1083, "B"
-    find_lex $P1085, "$/"
-    $P1086 = $P1080."new"("\b", "enumcharlist" :named("pasttype"), $I1084 :named("negate"), $P1085 :named("node"))
+    find_lex $P1088, "$/"
+    unless_null $P1088, vivify_277
+    $P1088 = root_new ['parrot';'Hash']
+  vivify_277:
+    set $P1089, $P1088["sym"]
+    unless_null $P1089, vivify_278
+    new $P1089, "Undef"
+  vivify_278:
+    set $S1090, $P1089
+    iseq $I1091, $S1090, "B"
+    find_lex $P1092, "$/"
+    $P1093 = $P1087."new"("\b", "enumcharlist" :named("pasttype"), $I1091 :named("negate"), $P1092 :named("node"))
 .annotate 'line', 287
-    store_lex "$past", $P1086
+    store_lex "$past", $P1093
 .annotate 'line', 289
-    find_lex $P1087, "$/"
-    find_lex $P1088, "$past"
-    $P1089 = $P1087."!make"($P1088)
+    find_lex $P1094, "$/"
+    find_lex $P1095, "$past"
+    $P1096 = $P1094."!make"($P1095)
 .annotate 'line', 286
-    .return ($P1089)
-  control_1076:
+    .return ($P1096)
+  control_1083:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1090, exception, "payload"
-    .return ($P1090)
+    getattribute $P1097, exception, "payload"
+    .return ($P1097)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<e>"  :subid("66_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1094
+.sub "backslash:sym<e>"  :subid("66_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1101
 .annotate 'line', 292
-    new $P1093, 'ExceptionHandler'
-    set_addr $P1093, control_1092
-    $P1093."handle_types"(.CONTROL_RETURN)
-    push_eh $P1093
+    new $P1100, 'ExceptionHandler'
+    set_addr $P1100, control_1099
+    $P1100."handle_types"(.CONTROL_RETURN)
+    push_eh $P1100
     .lex "self", self
-    .lex "$/", param_1094
+    .lex "$/", param_1101
 .annotate 'line', 293
-    new $P1095, "Undef"
-    .lex "$past", $P1095
-    get_hll_global $P1096, ["PAST"], "Regex"
+    new $P1102, "Undef"
+    .lex "$past", $P1102
+    get_hll_global $P1103, ["PAST"], "Regex"
 .annotate 'line', 294
-    find_lex $P1097, "$/"
-    unless_null $P1097, vivify_275
-    $P1097 = root_new ['parrot';'Hash']
-  vivify_275:
-    set $P1098, $P1097["sym"]
-    unless_null $P1098, vivify_276
-    new $P1098, "Undef"
-  vivify_276:
-    set $S1099, $P1098
-    iseq $I1100, $S1099, "E"
-    find_lex $P1101, "$/"
-    $P1102 = $P1096."new"("\e", "enumcharlist" :named("pasttype"), $I1100 :named("negate"), $P1101 :named("node"))
+    find_lex $P1104, "$/"
+    unless_null $P1104, vivify_279
+    $P1104 = root_new ['parrot';'Hash']
+  vivify_279:
+    set $P1105, $P1104["sym"]
+    unless_null $P1105, vivify_280
+    new $P1105, "Undef"
+  vivify_280:
+    set $S1106, $P1105
+    iseq $I1107, $S1106, "E"
+    find_lex $P1108, "$/"
+    $P1109 = $P1103."new"("\e", "enumcharlist" :named("pasttype"), $I1107 :named("negate"), $P1108 :named("node"))
 .annotate 'line', 293
-    store_lex "$past", $P1102
+    store_lex "$past", $P1109
 .annotate 'line', 295
-    find_lex $P1103, "$/"
-    find_lex $P1104, "$past"
-    $P1105 = $P1103."!make"($P1104)
+    find_lex $P1110, "$/"
+    find_lex $P1111, "$past"
+    $P1112 = $P1110."!make"($P1111)
 .annotate 'line', 292
-    .return ($P1105)
-  control_1092:
+    .return ($P1112)
+  control_1099:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1106, exception, "payload"
-    .return ($P1106)
+    getattribute $P1113, exception, "payload"
+    .return ($P1113)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<f>"  :subid("67_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1110
+.sub "backslash:sym<f>"  :subid("67_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1117
 .annotate 'line', 298
-    new $P1109, 'ExceptionHandler'
-    set_addr $P1109, control_1108
-    $P1109."handle_types"(.CONTROL_RETURN)
-    push_eh $P1109
+    new $P1116, 'ExceptionHandler'
+    set_addr $P1116, control_1115
+    $P1116."handle_types"(.CONTROL_RETURN)
+    push_eh $P1116
     .lex "self", self
-    .lex "$/", param_1110
+    .lex "$/", param_1117
 .annotate 'line', 299
-    new $P1111, "Undef"
-    .lex "$past", $P1111
-    get_hll_global $P1112, ["PAST"], "Regex"
+    new $P1118, "Undef"
+    .lex "$past", $P1118
+    get_hll_global $P1119, ["PAST"], "Regex"
 .annotate 'line', 300
-    find_lex $P1113, "$/"
-    unless_null $P1113, vivify_277
-    $P1113 = root_new ['parrot';'Hash']
-  vivify_277:
-    set $P1114, $P1113["sym"]
-    unless_null $P1114, vivify_278
-    new $P1114, "Undef"
-  vivify_278:
-    set $S1115, $P1114
-    iseq $I1116, $S1115, "F"
-    find_lex $P1117, "$/"
-    $P1118 = $P1112."new"("\f", "enumcharlist" :named("pasttype"), $I1116 :named("negate"), $P1117 :named("node"))
+    find_lex $P1120, "$/"
+    unless_null $P1120, vivify_281
+    $P1120 = root_new ['parrot';'Hash']
+  vivify_281:
+    set $P1121, $P1120["sym"]
+    unless_null $P1121, vivify_282
+    new $P1121, "Undef"
+  vivify_282:
+    set $S1122, $P1121
+    iseq $I1123, $S1122, "F"
+    find_lex $P1124, "$/"
+    $P1125 = $P1119."new"("\f", "enumcharlist" :named("pasttype"), $I1123 :named("negate"), $P1124 :named("node"))
 .annotate 'line', 299
-    store_lex "$past", $P1118
+    store_lex "$past", $P1125
 .annotate 'line', 301
-    find_lex $P1119, "$/"
-    find_lex $P1120, "$past"
-    $P1121 = $P1119."!make"($P1120)
+    find_lex $P1126, "$/"
+    find_lex $P1127, "$past"
+    $P1128 = $P1126."!make"($P1127)
 .annotate 'line', 298
-    .return ($P1121)
-  control_1108:
+    .return ($P1128)
+  control_1115:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1122, exception, "payload"
-    .return ($P1122)
+    getattribute $P1129, exception, "payload"
+    .return ($P1129)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<h>"  :subid("68_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1126
+.sub "backslash:sym<h>"  :subid("68_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1133
 .annotate 'line', 304
-    new $P1125, 'ExceptionHandler'
-    set_addr $P1125, control_1124
-    $P1125."handle_types"(.CONTROL_RETURN)
-    push_eh $P1125
+    new $P1132, 'ExceptionHandler'
+    set_addr $P1132, control_1131
+    $P1132."handle_types"(.CONTROL_RETURN)
+    push_eh $P1132
     .lex "self", self
-    .lex "$/", param_1126
+    .lex "$/", param_1133
 .annotate 'line', 305
-    new $P1127, "Undef"
-    .lex "$past", $P1127
-    get_hll_global $P1128, ["PAST"], "Regex"
+    new $P1134, "Undef"
+    .lex "$past", $P1134
+    get_hll_global $P1135, ["PAST"], "Regex"
 .annotate 'line', 306
-    find_lex $P1129, "$/"
-    unless_null $P1129, vivify_279
-    $P1129 = root_new ['parrot';'Hash']
-  vivify_279:
-    set $P1130, $P1129["sym"]
-    unless_null $P1130, vivify_280
-    new $P1130, "Undef"
-  vivify_280:
-    set $S1131, $P1130
-    iseq $I1132, $S1131, "H"
-    find_lex $P1133, "$/"
-    $P1134 = $P1128."new"(unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", "enumcharlist" :named("pasttype"), $I1132 :named("negate"), $P1133 :named("node"))
+    find_lex $P1136, "$/"
+    unless_null $P1136, vivify_283
+    $P1136 = root_new ['parrot';'Hash']
+  vivify_283:
+    set $P1137, $P1136["sym"]
+    unless_null $P1137, vivify_284
+    new $P1137, "Undef"
+  vivify_284:
+    set $S1138, $P1137
+    iseq $I1139, $S1138, "H"
+    find_lex $P1140, "$/"
+    $P1141 = $P1135."new"(unicode:"\t \x{a0}\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000", "enumcharlist" :named("pasttype"), $I1139 :named("negate"), $P1140 :named("node"))
 .annotate 'line', 305
-    store_lex "$past", $P1134
+    store_lex "$past", $P1141
 .annotate 'line', 307
-    find_lex $P1135, "$/"
-    find_lex $P1136, "$past"
-    $P1137 = $P1135."!make"($P1136)
+    find_lex $P1142, "$/"
+    find_lex $P1143, "$past"
+    $P1144 = $P1142."!make"($P1143)
 .annotate 'line', 304
-    .return ($P1137)
-  control_1124:
+    .return ($P1144)
+  control_1131:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1138, exception, "payload"
-    .return ($P1138)
+    getattribute $P1145, exception, "payload"
+    .return ($P1145)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<r>"  :subid("69_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1142
+.sub "backslash:sym<r>"  :subid("69_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1149
 .annotate 'line', 310
-    new $P1141, 'ExceptionHandler'
-    set_addr $P1141, control_1140
-    $P1141."handle_types"(.CONTROL_RETURN)
-    push_eh $P1141
+    new $P1148, 'ExceptionHandler'
+    set_addr $P1148, control_1147
+    $P1148."handle_types"(.CONTROL_RETURN)
+    push_eh $P1148
     .lex "self", self
-    .lex "$/", param_1142
+    .lex "$/", param_1149
 .annotate 'line', 311
-    new $P1143, "Undef"
-    .lex "$past", $P1143
-    get_hll_global $P1144, ["PAST"], "Regex"
+    new $P1150, "Undef"
+    .lex "$past", $P1150
+    get_hll_global $P1151, ["PAST"], "Regex"
 .annotate 'line', 312
-    find_lex $P1145, "$/"
-    unless_null $P1145, vivify_281
-    $P1145 = root_new ['parrot';'Hash']
-  vivify_281:
-    set $P1146, $P1145["sym"]
-    unless_null $P1146, vivify_282
-    new $P1146, "Undef"
-  vivify_282:
-    set $S1147, $P1146
-    iseq $I1148, $S1147, "R"
-    find_lex $P1149, "$/"
-    $P1150 = $P1144."new"("\r", "enumcharlist" :named("pasttype"), $I1148 :named("negate"), $P1149 :named("node"))
+    find_lex $P1152, "$/"
+    unless_null $P1152, vivify_285
+    $P1152 = root_new ['parrot';'Hash']
+  vivify_285:
+    set $P1153, $P1152["sym"]
+    unless_null $P1153, vivify_286
+    new $P1153, "Undef"
+  vivify_286:
+    set $S1154, $P1153
+    iseq $I1155, $S1154, "R"
+    find_lex $P1156, "$/"
+    $P1157 = $P1151."new"("\r", "enumcharlist" :named("pasttype"), $I1155 :named("negate"), $P1156 :named("node"))
 .annotate 'line', 311
-    store_lex "$past", $P1150
+    store_lex "$past", $P1157
 .annotate 'line', 313
-    find_lex $P1151, "$/"
-    find_lex $P1152, "$past"
-    $P1153 = $P1151."!make"($P1152)
+    find_lex $P1158, "$/"
+    find_lex $P1159, "$past"
+    $P1160 = $P1158."!make"($P1159)
 .annotate 'line', 310
-    .return ($P1153)
-  control_1140:
+    .return ($P1160)
+  control_1147:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1154, exception, "payload"
-    .return ($P1154)
+    getattribute $P1161, exception, "payload"
+    .return ($P1161)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<t>"  :subid("70_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1158
+.sub "backslash:sym<t>"  :subid("70_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1165
 .annotate 'line', 316
-    new $P1157, 'ExceptionHandler'
-    set_addr $P1157, control_1156
-    $P1157."handle_types"(.CONTROL_RETURN)
-    push_eh $P1157
+    new $P1164, 'ExceptionHandler'
+    set_addr $P1164, control_1163
+    $P1164."handle_types"(.CONTROL_RETURN)
+    push_eh $P1164
     .lex "self", self
-    .lex "$/", param_1158
+    .lex "$/", param_1165
 .annotate 'line', 317
-    new $P1159, "Undef"
-    .lex "$past", $P1159
-    get_hll_global $P1160, ["PAST"], "Regex"
+    new $P1166, "Undef"
+    .lex "$past", $P1166
+    get_hll_global $P1167, ["PAST"], "Regex"
 .annotate 'line', 318
-    find_lex $P1161, "$/"
-    unless_null $P1161, vivify_283
-    $P1161 = root_new ['parrot';'Hash']
-  vivify_283:
-    set $P1162, $P1161["sym"]
-    unless_null $P1162, vivify_284
-    new $P1162, "Undef"
-  vivify_284:
-    set $S1163, $P1162
-    iseq $I1164, $S1163, "T"
-    find_lex $P1165, "$/"
-    $P1166 = $P1160."new"("\t", "enumcharlist" :named("pasttype"), $I1164 :named("negate"), $P1165 :named("node"))
+    find_lex $P1168, "$/"
+    unless_null $P1168, vivify_287
+    $P1168 = root_new ['parrot';'Hash']
+  vivify_287:
+    set $P1169, $P1168["sym"]
+    unless_null $P1169, vivify_288
+    new $P1169, "Undef"
+  vivify_288:
+    set $S1170, $P1169
+    iseq $I1171, $S1170, "T"
+    find_lex $P1172, "$/"
+    $P1173 = $P1167."new"("\t", "enumcharlist" :named("pasttype"), $I1171 :named("negate"), $P1172 :named("node"))
 .annotate 'line', 317
-    store_lex "$past", $P1166
+    store_lex "$past", $P1173
 .annotate 'line', 319
-    find_lex $P1167, "$/"
-    find_lex $P1168, "$past"
-    $P1169 = $P1167."!make"($P1168)
+    find_lex $P1174, "$/"
+    find_lex $P1175, "$past"
+    $P1176 = $P1174."!make"($P1175)
 .annotate 'line', 316
-    .return ($P1169)
-  control_1156:
+    .return ($P1176)
+  control_1163:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1170, exception, "payload"
-    .return ($P1170)
+    getattribute $P1177, exception, "payload"
+    .return ($P1177)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<v>"  :subid("71_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1174
+.sub "backslash:sym<v>"  :subid("71_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1181
 .annotate 'line', 322
-    new $P1173, 'ExceptionHandler'
-    set_addr $P1173, control_1172
-    $P1173."handle_types"(.CONTROL_RETURN)
-    push_eh $P1173
+    new $P1180, 'ExceptionHandler'
+    set_addr $P1180, control_1179
+    $P1180."handle_types"(.CONTROL_RETURN)
+    push_eh $P1180
     .lex "self", self
-    .lex "$/", param_1174
+    .lex "$/", param_1181
 .annotate 'line', 323
-    new $P1175, "Undef"
-    .lex "$past", $P1175
-    get_hll_global $P1176, ["PAST"], "Regex"
-.annotate 'line', 325
-    find_lex $P1177, "$/"
-    unless_null $P1177, vivify_285
-    $P1177 = root_new ['parrot';'Hash']
-  vivify_285:
-    set $P1178, $P1177["sym"]
-    unless_null $P1178, vivify_286
-    new $P1178, "Undef"
-  vivify_286:
-    set $S1179, $P1178
-    iseq $I1180, $S1179, "V"
-    find_lex $P1181, "$/"
-    $P1182 = $P1176."new"(unicode:"\n\x{b}\f\r\x{85}\u2028\u2029", "enumcharlist" :named("pasttype"), $I1180 :named("negate"), $P1181 :named("node"))
+    new $P1182, "Undef"
+    .lex "$past", $P1182
+    get_hll_global $P1183, ["PAST"], "Regex"
+.annotate 'line', 325
+    find_lex $P1184, "$/"
+    unless_null $P1184, vivify_289
+    $P1184 = root_new ['parrot';'Hash']
+  vivify_289:
+    set $P1185, $P1184["sym"]
+    unless_null $P1185, vivify_290
+    new $P1185, "Undef"
+  vivify_290:
+    set $S1186, $P1185
+    iseq $I1187, $S1186, "V"
+    find_lex $P1188, "$/"
+    $P1189 = $P1183."new"(unicode:"\n\x{b}\f\r\x{85}\u2028\u2029", "enumcharlist" :named("pasttype"), $I1187 :named("negate"), $P1188 :named("node"))
 .annotate 'line', 323
-    store_lex "$past", $P1182
+    store_lex "$past", $P1189
 .annotate 'line', 326
-    find_lex $P1183, "$/"
-    find_lex $P1184, "$past"
-    $P1185 = $P1183."!make"($P1184)
+    find_lex $P1190, "$/"
+    find_lex $P1191, "$past"
+    $P1192 = $P1190."!make"($P1191)
 .annotate 'line', 322
-    .return ($P1185)
-  control_1172:
+    .return ($P1192)
+  control_1179:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1186, exception, "payload"
-    .return ($P1186)
+    getattribute $P1193, exception, "payload"
+    .return ($P1193)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<o>"  :subid("72_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1190
+.sub "backslash:sym<o>"  :subid("72_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1197
 .annotate 'line', 329
-    new $P1189, 'ExceptionHandler'
-    set_addr $P1189, control_1188
-    $P1189."handle_types"(.CONTROL_RETURN)
-    push_eh $P1189
+    new $P1196, 'ExceptionHandler'
+    set_addr $P1196, control_1195
+    $P1196."handle_types"(.CONTROL_RETURN)
+    push_eh $P1196
     .lex "self", self
-    .lex "$/", param_1190
+    .lex "$/", param_1197
 .annotate 'line', 330
-    new $P1191, "Undef"
-    .lex "$octlit", $P1191
+    new $P1198, "Undef"
+    .lex "$octlit", $P1198
 .annotate 'line', 331
-    get_hll_global $P1192, ["HLL";"Actions"], "ints_to_string"
-    find_lex $P1195, "$/"
-    unless_null $P1195, vivify_287
-    $P1195 = root_new ['parrot';'Hash']
-  vivify_287:
-    set $P1196, $P1195["octint"]
-    unless_null $P1196, vivify_288
-    new $P1196, "Undef"
-  vivify_288:
-    unless $P1196, unless_1194
-    set $P1193, $P1196
-    goto unless_1194_end
-  unless_1194:
-    find_lex $P1197, "$/"
-    unless_null $P1197, vivify_289
-    $P1197 = root_new ['parrot';'Hash']
-  vivify_289:
-    set $P1198, $P1197["octints"]
-    unless_null $P1198, vivify_290
-    $P1198 = root_new ['parrot';'Hash']
-  vivify_290:
-    set $P1199, $P1198["octint"]
-    unless_null $P1199, vivify_291
-    new $P1199, "Undef"
+    get_hll_global $P1199, ["HLL";"Actions"], "ints_to_string"
+    find_lex $P1202, "$/"
+    unless_null $P1202, vivify_291
+    $P1202 = root_new ['parrot';'Hash']
   vivify_291:
-    set $P1193, $P1199
-  unless_1194_end:
-    $P1200 = $P1192($P1193)
-    store_lex "$octlit", $P1200
-.annotate 'line', 332
-    find_lex $P1201, "$/"
+    set $P1203, $P1202["octint"]
+    unless_null $P1203, vivify_292
+    new $P1203, "Undef"
+  vivify_292:
+    unless $P1203, unless_1201
+    set $P1200, $P1203
+    goto unless_1201_end
+  unless_1201:
     find_lex $P1204, "$/"
-    unless_null $P1204, vivify_292
+    unless_null $P1204, vivify_293
     $P1204 = root_new ['parrot';'Hash']
-  vivify_292:
-    set $P1205, $P1204["sym"]
-    unless_null $P1205, vivify_293
-    new $P1205, "Undef"
   vivify_293:
-    set $S1206, $P1205
-    iseq $I1207, $S1206, "O"
-    if $I1207, if_1203
+    set $P1205, $P1204["octints"]
+    unless_null $P1205, vivify_294
+    $P1205 = root_new ['parrot';'Hash']
+  vivify_294:
+    set $P1206, $P1205["octint"]
+    unless_null $P1206, vivify_295
+    new $P1206, "Undef"
+  vivify_295:
+    set $P1200, $P1206
+  unless_1201_end:
+    $P1207 = $P1199($P1200)
+    store_lex "$octlit", $P1207
+.annotate 'line', 332
+    find_lex $P1208, "$/"
+    find_lex $P1211, "$/"
+    unless_null $P1211, vivify_296
+    $P1211 = root_new ['parrot';'Hash']
+  vivify_296:
+    set $P1212, $P1211["sym"]
+    unless_null $P1212, vivify_297
+    new $P1212, "Undef"
+  vivify_297:
+    set $S1213, $P1212
+    iseq $I1214, $S1213, "O"
+    if $I1214, if_1210
 .annotate 'line', 335
-    get_hll_global $P1212, ["PAST"], "Regex"
-    find_lex $P1213, "$octlit"
-    find_lex $P1214, "$/"
-    $P1215 = $P1212."new"($P1213, "literal" :named("pasttype"), $P1214 :named("node"))
-    set $P1202, $P1215
+    get_hll_global $P1219, ["PAST"], "Regex"
+    find_lex $P1220, "$octlit"
+    find_lex $P1221, "$/"
+    $P1222 = $P1219."new"($P1220, "literal" :named("pasttype"), $P1221 :named("node"))
+    set $P1209, $P1222
 .annotate 'line', 332
-    goto if_1203_end
-  if_1203:
+    goto if_1210_end
+  if_1210:
 .annotate 'line', 333
-    get_hll_global $P1208, ["PAST"], "Regex"
-    find_lex $P1209, "$octlit"
-    find_lex $P1210, "$/"
-    $P1211 = $P1208."new"($P1209, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1210 :named("node"))
-    set $P1202, $P1211
-  if_1203_end:
-    $P1216 = $P1201."!make"($P1202)
+    get_hll_global $P1215, ["PAST"], "Regex"
+    find_lex $P1216, "$octlit"
+    find_lex $P1217, "$/"
+    $P1218 = $P1215."new"($P1216, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1217 :named("node"))
+    set $P1209, $P1218
+  if_1210_end:
+    $P1223 = $P1208."!make"($P1209)
 .annotate 'line', 329
-    .return ($P1216)
-  control_1188:
+    .return ($P1223)
+  control_1195:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1217, exception, "payload"
-    .return ($P1217)
+    getattribute $P1224, exception, "payload"
+    .return ($P1224)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<x>"  :subid("73_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1221
+.sub "backslash:sym<x>"  :subid("73_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1228
 .annotate 'line', 338
-    new $P1220, 'ExceptionHandler'
-    set_addr $P1220, control_1219
-    $P1220."handle_types"(.CONTROL_RETURN)
-    push_eh $P1220
+    new $P1227, 'ExceptionHandler'
+    set_addr $P1227, control_1226
+    $P1227."handle_types"(.CONTROL_RETURN)
+    push_eh $P1227
     .lex "self", self
-    .lex "$/", param_1221
+    .lex "$/", param_1228
 .annotate 'line', 339
-    new $P1222, "Undef"
-    .lex "$hexlit", $P1222
+    new $P1229, "Undef"
+    .lex "$hexlit", $P1229
 .annotate 'line', 340
-    get_hll_global $P1223, ["HLL";"Actions"], "ints_to_string"
-    find_lex $P1226, "$/"
-    unless_null $P1226, vivify_294
-    $P1226 = root_new ['parrot';'Hash']
-  vivify_294:
-    set $P1227, $P1226["hexint"]
-    unless_null $P1227, vivify_295
-    new $P1227, "Undef"
-  vivify_295:
-    unless $P1227, unless_1225
-    set $P1224, $P1227
-    goto unless_1225_end
-  unless_1225:
-    find_lex $P1228, "$/"
-    unless_null $P1228, vivify_296
-    $P1228 = root_new ['parrot';'Hash']
-  vivify_296:
-    set $P1229, $P1228["hexints"]
-    unless_null $P1229, vivify_297
-    $P1229 = root_new ['parrot';'Hash']
-  vivify_297:
-    set $P1230, $P1229["hexint"]
-    unless_null $P1230, vivify_298
-    new $P1230, "Undef"
+    get_hll_global $P1230, ["HLL";"Actions"], "ints_to_string"
+    find_lex $P1233, "$/"
+    unless_null $P1233, vivify_298
+    $P1233 = root_new ['parrot';'Hash']
   vivify_298:
-    set $P1224, $P1230
-  unless_1225_end:
-    $P1231 = $P1223($P1224)
-    store_lex "$hexlit", $P1231
-.annotate 'line', 341
-    find_lex $P1232, "$/"
+    set $P1234, $P1233["hexint"]
+    unless_null $P1234, vivify_299
+    new $P1234, "Undef"
+  vivify_299:
+    unless $P1234, unless_1232
+    set $P1231, $P1234
+    goto unless_1232_end
+  unless_1232:
     find_lex $P1235, "$/"
-    unless_null $P1235, vivify_299
+    unless_null $P1235, vivify_300
     $P1235 = root_new ['parrot';'Hash']
-  vivify_299:
-    set $P1236, $P1235["sym"]
-    unless_null $P1236, vivify_300
-    new $P1236, "Undef"
   vivify_300:
-    set $S1237, $P1236
-    iseq $I1238, $S1237, "X"
-    if $I1238, if_1234
+    set $P1236, $P1235["hexints"]
+    unless_null $P1236, vivify_301
+    $P1236 = root_new ['parrot';'Hash']
+  vivify_301:
+    set $P1237, $P1236["hexint"]
+    unless_null $P1237, vivify_302
+    new $P1237, "Undef"
+  vivify_302:
+    set $P1231, $P1237
+  unless_1232_end:
+    $P1238 = $P1230($P1231)
+    store_lex "$hexlit", $P1238
+.annotate 'line', 341
+    find_lex $P1239, "$/"
+    find_lex $P1242, "$/"
+    unless_null $P1242, vivify_303
+    $P1242 = root_new ['parrot';'Hash']
+  vivify_303:
+    set $P1243, $P1242["sym"]
+    unless_null $P1243, vivify_304
+    new $P1243, "Undef"
+  vivify_304:
+    set $S1244, $P1243
+    iseq $I1245, $S1244, "X"
+    if $I1245, if_1241
 .annotate 'line', 344
-    get_hll_global $P1243, ["PAST"], "Regex"
-    find_lex $P1244, "$hexlit"
-    find_lex $P1245, "$/"
-    $P1246 = $P1243."new"($P1244, "literal" :named("pasttype"), $P1245 :named("node"))
-    set $P1233, $P1246
+    get_hll_global $P1250, ["PAST"], "Regex"
+    find_lex $P1251, "$hexlit"
+    find_lex $P1252, "$/"
+    $P1253 = $P1250."new"($P1251, "literal" :named("pasttype"), $P1252 :named("node"))
+    set $P1240, $P1253
 .annotate 'line', 341
-    goto if_1234_end
-  if_1234:
+    goto if_1241_end
+  if_1241:
 .annotate 'line', 342
-    get_hll_global $P1239, ["PAST"], "Regex"
-    find_lex $P1240, "$hexlit"
-    find_lex $P1241, "$/"
-    $P1242 = $P1239."new"($P1240, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1241 :named("node"))
-    set $P1233, $P1242
-  if_1234_end:
-    $P1247 = $P1232."!make"($P1233)
+    get_hll_global $P1246, ["PAST"], "Regex"
+    find_lex $P1247, "$hexlit"
+    find_lex $P1248, "$/"
+    $P1249 = $P1246."new"($P1247, "enumcharlist" :named("pasttype"), 1 :named("negate"), $P1248 :named("node"))
+    set $P1240, $P1249
+  if_1241_end:
+    $P1254 = $P1239."!make"($P1240)
 .annotate 'line', 338
-    .return ($P1247)
-  control_1219:
+    .return ($P1254)
+  control_1226:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1248, exception, "payload"
-    .return ($P1248)
+    getattribute $P1255, exception, "payload"
+    .return ($P1255)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<c>"  :subid("74_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1252
+.sub "backslash:sym<c>"  :subid("74_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1259
 .annotate 'line', 347
-    new $P1251, 'ExceptionHandler'
-    set_addr $P1251, control_1250
-    $P1251."handle_types"(.CONTROL_RETURN)
-    push_eh $P1251
+    new $P1258, 'ExceptionHandler'
+    set_addr $P1258, control_1257
+    $P1258."handle_types"(.CONTROL_RETURN)
+    push_eh $P1258
     .lex "self", self
-    .lex "$/", param_1252
+    .lex "$/", param_1259
 .annotate 'line', 348
-    find_lex $P1253, "$/"
-    get_hll_global $P1254, ["PAST"], "Regex"
-    find_lex $P1255, "$/"
-    unless_null $P1255, vivify_301
-    $P1255 = root_new ['parrot';'Hash']
-  vivify_301:
-    set $P1256, $P1255["charspec"]
-    unless_null $P1256, vivify_302
-    new $P1256, "Undef"
-  vivify_302:
-    $P1257 = $P1256."ast"()
-    find_lex $P1258, "$/"
-    $P1259 = $P1254."new"($P1257, "literal" :named("pasttype"), $P1258 :named("node"))
-    $P1260 = $P1253."!make"($P1259)
+    find_lex $P1260, "$/"
+    get_hll_global $P1261, ["PAST"], "Regex"
+    find_lex $P1262, "$/"
+    unless_null $P1262, vivify_305
+    $P1262 = root_new ['parrot';'Hash']
+  vivify_305:
+    set $P1263, $P1262["charspec"]
+    unless_null $P1263, vivify_306
+    new $P1263, "Undef"
+  vivify_306:
+    $P1264 = $P1263."ast"()
+    find_lex $P1265, "$/"
+    $P1266 = $P1261."new"($P1264, "literal" :named("pasttype"), $P1265 :named("node"))
+    $P1267 = $P1260."!make"($P1266)
 .annotate 'line', 347
-    .return ($P1260)
-  control_1250:
+    .return ($P1267)
+  control_1257:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1261, exception, "payload"
-    .return ($P1261)
+    getattribute $P1268, exception, "payload"
+    .return ($P1268)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "backslash:sym<misc>"  :subid("75_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1265
+.sub "backslash:sym<misc>"  :subid("75_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1272
 .annotate 'line', 351
-    new $P1264, 'ExceptionHandler'
-    set_addr $P1264, control_1263
-    $P1264."handle_types"(.CONTROL_RETURN)
-    push_eh $P1264
+    new $P1271, 'ExceptionHandler'
+    set_addr $P1271, control_1270
+    $P1271."handle_types"(.CONTROL_RETURN)
+    push_eh $P1271
     .lex "self", self
-    .lex "$/", param_1265
+    .lex "$/", param_1272
 .annotate 'line', 352
-    new $P1266, "Undef"
-    .lex "$past", $P1266
-    get_hll_global $P1267, ["PAST"], "Regex"
-    find_lex $P1268, "$/"
-    set $S1269, $P1268
-    find_lex $P1270, "$/"
-    $P1271 = $P1267."new"($S1269, "literal" :named("pasttype"), $P1270 :named("node"))
-    store_lex "$past", $P1271
+    new $P1273, "Undef"
+    .lex "$past", $P1273
+    get_hll_global $P1274, ["PAST"], "Regex"
+    find_lex $P1275, "$/"
+    set $S1276, $P1275
+    find_lex $P1277, "$/"
+    $P1278 = $P1274."new"($S1276, "literal" :named("pasttype"), $P1277 :named("node"))
+    store_lex "$past", $P1278
 .annotate 'line', 353
-    find_lex $P1272, "$/"
-    find_lex $P1273, "$past"
-    $P1274 = $P1272."!make"($P1273)
+    find_lex $P1279, "$/"
+    find_lex $P1280, "$past"
+    $P1281 = $P1279."!make"($P1280)
 .annotate 'line', 351
-    .return ($P1274)
-  control_1263:
+    .return ($P1281)
+  control_1270:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1275, exception, "payload"
-    .return ($P1275)
+    getattribute $P1282, exception, "payload"
+    .return ($P1282)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "assertion:sym<?>"  :subid("76_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1279
+.sub "assertion:sym<?>"  :subid("76_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1286
 .annotate 'line', 357
-    new $P1278, 'ExceptionHandler'
-    set_addr $P1278, control_1277
-    $P1278."handle_types"(.CONTROL_RETURN)
-    push_eh $P1278
+    new $P1285, 'ExceptionHandler'
+    set_addr $P1285, control_1284
+    $P1285."handle_types"(.CONTROL_RETURN)
+    push_eh $P1285
     .lex "self", self
-    .lex "$/", param_1279
+    .lex "$/", param_1286
 .annotate 'line', 358
-    new $P1280, "Undef"
-    .lex "$past", $P1280
+    new $P1287, "Undef"
+    .lex "$past", $P1287
 .annotate 'line', 357
-    find_lex $P1281, "$past"
+    find_lex $P1288, "$past"
 .annotate 'line', 359
-    find_lex $P1283, "$/"
-    unless_null $P1283, vivify_303
-    $P1283 = root_new ['parrot';'Hash']
-  vivify_303:
-    set $P1284, $P1283["assertion"]
-    unless_null $P1284, vivify_304
-    new $P1284, "Undef"
-  vivify_304:
-    if $P1284, if_1282
+    find_lex $P1290, "$/"
+    unless_null $P1290, vivify_307
+    $P1290 = root_new ['parrot';'Hash']
+  vivify_307:
+    set $P1291, $P1290["assertion"]
+    unless_null $P1291, vivify_308
+    new $P1291, "Undef"
+  vivify_308:
+    if $P1291, if_1289
 .annotate 'line', 363
-    new $P1289, "Integer"
-    assign $P1289, 0
-    store_lex "$past", $P1289
-    goto if_1282_end
-  if_1282:
+    new $P1296, "Integer"
+    assign $P1296, 0
+    store_lex "$past", $P1296
+    goto if_1289_end
+  if_1289:
 .annotate 'line', 360
-    find_lex $P1285, "$/"
-    unless_null $P1285, vivify_305
-    $P1285 = root_new ['parrot';'Hash']
-  vivify_305:
-    set $P1286, $P1285["assertion"]
-    unless_null $P1286, vivify_306
-    new $P1286, "Undef"
-  vivify_306:
-    $P1287 = $P1286."ast"()
-    store_lex "$past", $P1287
+    find_lex $P1292, "$/"
+    unless_null $P1292, vivify_309
+    $P1292 = root_new ['parrot';'Hash']
+  vivify_309:
+    set $P1293, $P1292["assertion"]
+    unless_null $P1293, vivify_310
+    new $P1293, "Undef"
+  vivify_310:
+    $P1294 = $P1293."ast"()
+    store_lex "$past", $P1294
 .annotate 'line', 361
-    find_lex $P1288, "$past"
-    $P1288."subtype"("zerowidth")
-  if_1282_end:
+    find_lex $P1295, "$past"
+    $P1295."subtype"("zerowidth")
+  if_1289_end:
 .annotate 'line', 364
-    find_lex $P1290, "$/"
-    find_lex $P1291, "$past"
-    $P1292 = $P1290."!make"($P1291)
+    find_lex $P1297, "$/"
+    find_lex $P1298, "$past"
+    $P1299 = $P1297."!make"($P1298)
 .annotate 'line', 357
-    .return ($P1292)
-  control_1277:
+    .return ($P1299)
+  control_1284:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1293, exception, "payload"
-    .return ($P1293)
+    getattribute $P1300, exception, "payload"
+    .return ($P1300)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "assertion:sym<!>"  :subid("77_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1297
+.sub "assertion:sym<!>"  :subid("77_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1304
 .annotate 'line', 367
-    new $P1296, 'ExceptionHandler'
-    set_addr $P1296, control_1295
-    $P1296."handle_types"(.CONTROL_RETURN)
-    push_eh $P1296
+    new $P1303, 'ExceptionHandler'
+    set_addr $P1303, control_1302
+    $P1303."handle_types"(.CONTROL_RETURN)
+    push_eh $P1303
     .lex "self", self
-    .lex "$/", param_1297
+    .lex "$/", param_1304
 .annotate 'line', 368
-    new $P1298, "Undef"
-    .lex "$past", $P1298
+    new $P1305, "Undef"
+    .lex "$past", $P1305
 .annotate 'line', 367
-    find_lex $P1299, "$past"
+    find_lex $P1306, "$past"
 .annotate 'line', 369
-    find_lex $P1301, "$/"
-    unless_null $P1301, vivify_307
-    $P1301 = root_new ['parrot';'Hash']
-  vivify_307:
-    set $P1302, $P1301["assertion"]
-    unless_null $P1302, vivify_308
-    new $P1302, "Undef"
-  vivify_308:
-    if $P1302, if_1300
+    find_lex $P1308, "$/"
+    unless_null $P1308, vivify_311
+    $P1308 = root_new ['parrot';'Hash']
+  vivify_311:
+    set $P1309, $P1308["assertion"]
+    unless_null $P1309, vivify_312
+    new $P1309, "Undef"
+  vivify_312:
+    if $P1309, if_1307
 .annotate 'line', 375
-    get_hll_global $P1311, ["PAST"], "Regex"
-    find_lex $P1312, "$/"
-    $P1313 = $P1311."new"("anchor" :named("pasttype"), "fail" :named("subtype"), $P1312 :named("node"))
-    store_lex "$past", $P1313
+    get_hll_global $P1318, ["PAST"], "Regex"
+    find_lex $P1319, "$/"
+    $P1320 = $P1318."new"("anchor" :named("pasttype"), "fail" :named("subtype"), $P1319 :named("node"))
+    store_lex "$past", $P1320
 .annotate 'line', 374
-    goto if_1300_end
-  if_1300:
+    goto if_1307_end
+  if_1307:
 .annotate 'line', 370
-    find_lex $P1303, "$/"
-    unless_null $P1303, vivify_309
-    $P1303 = root_new ['parrot';'Hash']
-  vivify_309:
-    set $P1304, $P1303["assertion"]
-    unless_null $P1304, vivify_310
-    new $P1304, "Undef"
-  vivify_310:
-    $P1305 = $P1304."ast"()
-    store_lex "$past", $P1305
+    find_lex $P1310, "$/"
+    unless_null $P1310, vivify_313
+    $P1310 = root_new ['parrot';'Hash']
+  vivify_313:
+    set $P1311, $P1310["assertion"]
+    unless_null $P1311, vivify_314
+    new $P1311, "Undef"
+  vivify_314:
+    $P1312 = $P1311."ast"()
+    store_lex "$past", $P1312
 .annotate 'line', 371
-    find_lex $P1306, "$past"
-    find_lex $P1307, "$past"
-    $P1308 = $P1307."negate"()
-    isfalse $I1309, $P1308
-    $P1306."negate"($I1309)
+    find_lex $P1313, "$past"
+    find_lex $P1314, "$past"
+    $P1315 = $P1314."negate"()
+    isfalse $I1316, $P1315
+    $P1313."negate"($I1316)
 .annotate 'line', 372
-    find_lex $P1310, "$past"
-    $P1310."subtype"("zerowidth")
-  if_1300_end:
+    find_lex $P1317, "$past"
+    $P1317."subtype"("zerowidth")
+  if_1307_end:
 .annotate 'line', 377
-    find_lex $P1314, "$/"
-    find_lex $P1315, "$past"
-    $P1316 = $P1314."!make"($P1315)
+    find_lex $P1321, "$/"
+    find_lex $P1322, "$past"
+    $P1323 = $P1321."!make"($P1322)
 .annotate 'line', 367
-    .return ($P1316)
-  control_1295:
+    .return ($P1323)
+  control_1302:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1317, exception, "payload"
-    .return ($P1317)
+    getattribute $P1324, exception, "payload"
+    .return ($P1324)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "assertion:sym<method>"  :subid("78_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1321
+.sub "assertion:sym<method>"  :subid("78_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1328
 .annotate 'line', 380
-    new $P1320, 'ExceptionHandler'
-    set_addr $P1320, control_1319
-    $P1320."handle_types"(.CONTROL_RETURN)
-    push_eh $P1320
+    new $P1327, 'ExceptionHandler'
+    set_addr $P1327, control_1326
+    $P1327."handle_types"(.CONTROL_RETURN)
+    push_eh $P1327
     .lex "self", self
-    .lex "$/", param_1321
+    .lex "$/", param_1328
 .annotate 'line', 381
-    new $P1322, "Undef"
-    .lex "$past", $P1322
-    find_lex $P1323, "$/"
-    unless_null $P1323, vivify_311
-    $P1323 = root_new ['parrot';'Hash']
-  vivify_311:
-    set $P1324, $P1323["assertion"]
-    unless_null $P1324, vivify_312
-    new $P1324, "Undef"
-  vivify_312:
-    $P1325 = $P1324."ast"()
-    store_lex "$past", $P1325
+    new $P1329, "Undef"
+    .lex "$past", $P1329
+    find_lex $P1330, "$/"
+    unless_null $P1330, vivify_315
+    $P1330 = root_new ['parrot';'Hash']
+  vivify_315:
+    set $P1331, $P1330["assertion"]
+    unless_null $P1331, vivify_316
+    new $P1331, "Undef"
+  vivify_316:
+    $P1332 = $P1331."ast"()
+    store_lex "$past", $P1332
 .annotate 'line', 382
-    find_lex $P1326, "$past"
-    $P1326."subtype"("method")
+    find_lex $P1333, "$past"
+    $P1333."subtype"("method")
 .annotate 'line', 383
-    find_lex $P1327, "$past"
-    $P1327."name"("")
+    find_lex $P1334, "$past"
+    $P1334."name"("")
 .annotate 'line', 384
-    find_lex $P1328, "$/"
-    find_lex $P1329, "$past"
-    $P1330 = $P1328."!make"($P1329)
+    find_lex $P1335, "$/"
+    find_lex $P1336, "$past"
+    $P1337 = $P1335."!make"($P1336)
 .annotate 'line', 380
-    .return ($P1330)
-  control_1319:
+    .return ($P1337)
+  control_1326:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1331, exception, "payload"
-    .return ($P1331)
+    getattribute $P1338, exception, "payload"
+    .return ($P1338)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "assertion:sym<name>"  :subid("79_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1335
+.sub "assertion:sym<name>"  :subid("79_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1342
 .annotate 'line', 387
-    .const 'Sub' $P1394 = "81_1278500533.96053" 
-    capture_lex $P1394
-    .const 'Sub' $P1358 = "80_1278500533.96053" 
-    capture_lex $P1358
-    new $P1334, 'ExceptionHandler'
-    set_addr $P1334, control_1333
-    $P1334."handle_types"(.CONTROL_RETURN)
-    push_eh $P1334
+    .const 'Sub' $P1365 = "80_1279529222.65073" 
+    capture_lex $P1365
+    new $P1341, 'ExceptionHandler'
+    set_addr $P1341, control_1340
+    $P1341."handle_types"(.CONTROL_RETURN)
+    push_eh $P1341
     .lex "self", self
-    .lex "$/", param_1335
+    .lex "$/", param_1342
 .annotate 'line', 388
-    new $P1336, "Undef"
-    .lex "$name", $P1336
+    new $P1343, "Undef"
+    .lex "$name", $P1343
 .annotate 'line', 389
-    new $P1337, "Undef"
-    .lex "$past", $P1337
+    new $P1344, "Undef"
+    .lex "$past", $P1344
 .annotate 'line', 388
-    find_lex $P1338, "$/"
-    unless_null $P1338, vivify_313
-    $P1338 = root_new ['parrot';'Hash']
-  vivify_313:
-    set $P1339, $P1338["longname"]
-    unless_null $P1339, vivify_314
-    new $P1339, "Undef"
-  vivify_314:
-    set $S1340, $P1339
-    new $P1341, 'String'
-    set $P1341, $S1340
-    store_lex "$name", $P1341
-    find_lex $P1342, "$past"
-.annotate 'line', 390
-    find_lex $P1344, "$/"
-    unless_null $P1344, vivify_315
-    $P1344 = root_new ['parrot';'Hash']
-  vivify_315:
-    set $P1345, $P1344["assertion"]
-    unless_null $P1345, vivify_316
-    new $P1345, "Undef"
-  vivify_316:
-    if $P1345, if_1343
-.annotate 'line', 394
-    find_lex $P1354, "$name"
-    set $S1355, $P1354
-    iseq $I1356, $S1355, "sym"
-    if $I1356, if_1353
-.annotate 'line', 410
-    get_hll_global $P1368, ["PAST"], "Regex"
-    find_lex $P1369, "$name"
-    find_lex $P1370, "$name"
-    find_lex $P1371, "$/"
-    $P1372 = $P1368."new"($P1369, $P1370 :named("name"), "subrule" :named("pasttype"), "capture" :named("subtype"), $P1371 :named("node"))
-    store_lex "$past", $P1372
-.annotate 'line', 412
-    find_lex $P1374, "$/"
-    unless_null $P1374, vivify_317
-    $P1374 = root_new ['parrot';'Hash']
+    find_lex $P1345, "$/"
+    unless_null $P1345, vivify_317
+    $P1345 = root_new ['parrot';'Hash']
   vivify_317:
-    set $P1375, $P1374["nibbler"]
-    unless_null $P1375, vivify_318
-    new $P1375, "Undef"
+    set $P1346, $P1345["longname"]
+    unless_null $P1346, vivify_318
+    new $P1346, "Undef"
   vivify_318:
-    if $P1375, if_1373
-.annotate 'line', 415
-    find_lex $P1383, "$/"
-    unless_null $P1383, vivify_319
-    $P1383 = root_new ['parrot';'Hash']
+    set $S1347, $P1346
+    new $P1348, 'String'
+    set $P1348, $S1347
+    store_lex "$name", $P1348
+    find_lex $P1349, "$past"
+.annotate 'line', 390
+    find_lex $P1351, "$/"
+    unless_null $P1351, vivify_319
+    $P1351 = root_new ['parrot';'Hash']
   vivify_319:
-    set $P1384, $P1383["arglist"]
-    unless_null $P1384, vivify_320
-    new $P1384, "Undef"
+    set $P1352, $P1351["assertion"]
+    unless_null $P1352, vivify_320
+    new $P1352, "Undef"
   vivify_320:
-    unless $P1384, if_1382_end
-.annotate 'line', 416
-    find_lex $P1386, "$/"
-    unless_null $P1386, vivify_321
-    $P1386 = root_new ['parrot';'Hash']
-  vivify_321:
-    set $P1387, $P1386["arglist"]
-    unless_null $P1387, vivify_322
-    $P1387 = root_new ['parrot';'ResizablePMCArray']
-  vivify_322:
-    set $P1388, $P1387[0]
-    unless_null $P1388, vivify_323
-    new $P1388, "Undef"
-  vivify_323:
-    $P1389 = $P1388."ast"()
-    $P1390 = $P1389."list"()
-    defined $I1391, $P1390
-    unless $I1391, for_undef_324
-    iter $P1385, $P1390
-    new $P1400, 'ExceptionHandler'
-    set_addr $P1400, loop1399_handler
-    $P1400."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P1400
-  loop1399_test:
-    unless $P1385, loop1399_done
-    shift $P1392, $P1385
-  loop1399_redo:
-    .const 'Sub' $P1394 = "81_1278500533.96053" 
-    capture_lex $P1394
-    $P1394($P1392)
-  loop1399_next:
-    goto loop1399_test
-  loop1399_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P1401, exception, 'type'
-    eq $P1401, .CONTROL_LOOP_NEXT, loop1399_next
-    eq $P1401, .CONTROL_LOOP_REDO, loop1399_redo
-  loop1399_done:
-    pop_eh 
-  for_undef_324:
-  if_1382_end:
-.annotate 'line', 415
-    goto if_1373_end
-  if_1373:
-.annotate 'line', 413
-    find_lex $P1376, "$past"
-    find_lex $P1377, "$/"
-    unless_null $P1377, vivify_325
-    $P1377 = root_new ['parrot';'Hash']
-  vivify_325:
-    set $P1378, $P1377["nibbler"]
-    unless_null $P1378, vivify_326
-    $P1378 = root_new ['parrot';'ResizablePMCArray']
-  vivify_326:
-    set $P1379, $P1378[0]
-    unless_null $P1379, vivify_327
-    new $P1379, "Undef"
-  vivify_327:
-    $P1380 = $P1379."ast"()
-    $P1381 = "buildsub"($P1380)
-    $P1376."push"($P1381)
-  if_1373_end:
+    if $P1352, if_1350
+.annotate 'line', 394
+    find_lex $P1361, "$name"
+    set $S1362, $P1361
+    iseq $I1363, $S1362, "sym"
+    if $I1363, if_1360
+.annotate 'line', 410
+    find_lex $P1375, "self"
+    find_lex $P1376, "$/"
+    $P1377 = $P1375."named_assertion"($P1376)
+    store_lex "$past", $P1377
 .annotate 'line', 409
-    goto if_1353_end
-  if_1353:
+    goto if_1360_end
+  if_1360:
 .annotate 'line', 394
-    .const 'Sub' $P1358 = "80_1278500533.96053" 
-    capture_lex $P1358
-    $P1358()
-  if_1353_end:
-    goto if_1343_end
-  if_1343:
+    .const 'Sub' $P1365 = "80_1279529222.65073" 
+    capture_lex $P1365
+    $P1365()
+  if_1360_end:
+    goto if_1350_end
+  if_1350:
 .annotate 'line', 391
-    find_lex $P1346, "$/"
-    unless_null $P1346, vivify_328
-    $P1346 = root_new ['parrot';'Hash']
-  vivify_328:
-    set $P1347, $P1346["assertion"]
-    unless_null $P1347, vivify_329
-    $P1347 = root_new ['parrot';'ResizablePMCArray']
-  vivify_329:
-    set $P1348, $P1347[0]
-    unless_null $P1348, vivify_330
-    new $P1348, "Undef"
-  vivify_330:
-    $P1349 = $P1348."ast"()
-    store_lex "$past", $P1349
+    find_lex $P1353, "$/"
+    unless_null $P1353, vivify_321
+    $P1353 = root_new ['parrot';'Hash']
+  vivify_321:
+    set $P1354, $P1353["assertion"]
+    unless_null $P1354, vivify_322
+    $P1354 = root_new ['parrot';'ResizablePMCArray']
+  vivify_322:
+    set $P1355, $P1354[0]
+    unless_null $P1355, vivify_323
+    new $P1355, "Undef"
+  vivify_323:
+    $P1356 = $P1355."ast"()
+    store_lex "$past", $P1356
 .annotate 'line', 392
-    find_lex $P1350, "self"
-    find_lex $P1351, "$past"
-    find_lex $P1352, "$name"
-    $P1350."subrule_alias"($P1351, $P1352)
-  if_1343_end:
-.annotate 'line', 419
-    find_lex $P1402, "$/"
-    find_lex $P1403, "$past"
-    $P1404 = $P1402."!make"($P1403)
+    find_lex $P1357, "self"
+    find_lex $P1358, "$past"
+    find_lex $P1359, "$name"
+    $P1357."subrule_alias"($P1358, $P1359)
+  if_1350_end:
+.annotate 'line', 412
+    find_lex $P1378, "$/"
+    find_lex $P1379, "$past"
+    $P1380 = $P1378."!make"($P1379)
 .annotate 'line', 387
-    .return ($P1404)
-  control_1333:
+    .return ($P1380)
+  control_1340:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1405, exception, "payload"
-    .return ($P1405)
-.end
-
-
-.namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1393"  :anon :subid("81_1278500533.96053") :outer("79_1278500533.96053")
-    .param pmc param_1395
-.annotate 'line', 416
-    .lex "$_", param_1395
-    find_lex $P1396, "$past"
-    find_lex $P1397, "$_"
-    $P1398 = $P1396."push"($P1397)
-    .return ($P1398)
+    getattribute $P1381, exception, "payload"
+    .return ($P1381)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1357"  :anon :subid("80_1278500533.96053") :outer("79_1278500533.96053")
+.sub "_block1364"  :anon :subid("80_1279529222.65073") :outer("79_1279529222.65073")
 .annotate 'line', 395
-    new $P1359, "Undef"
-    .lex "$regexsym", $P1359
+    new $P1366, "Undef"
+    .lex "$regexsym", $P1366
 
             $P0 = get_global '$REGEXNAME'
             $S0 = $P0
@@ -11580,390 +11825,390 @@
             add $I0, 5
             $S0 = substr $S0, $I0
             $S0 = chopn $S0, 1
-            $P1360 = box $S0
+            $P1367 = box $S0
         
-    store_lex "$regexsym", $P1360
+    store_lex "$regexsym", $P1367
 .annotate 'line', 404
-    get_hll_global $P1361, ["PAST"], "Regex"
+    get_hll_global $P1368, ["PAST"], "Regex"
 .annotate 'line', 405
-    get_hll_global $P1362, ["PAST"], "Regex"
-    find_lex $P1363, "$regexsym"
-    $P1364 = $P1362."new"($P1363, "literal" :named("pasttype"))
-    find_lex $P1365, "$name"
-    find_lex $P1366, "$/"
-    $P1367 = $P1361."new"($P1364, $P1365 :named("name"), "subcapture" :named("pasttype"), $P1366 :named("node"))
+    get_hll_global $P1369, ["PAST"], "Regex"
+    find_lex $P1370, "$regexsym"
+    $P1371 = $P1369."new"($P1370, "literal" :named("pasttype"))
+    find_lex $P1372, "$name"
+    find_lex $P1373, "$/"
+    $P1374 = $P1368."new"($P1371, $P1372 :named("name"), "subcapture" :named("pasttype"), $P1373 :named("node"))
 .annotate 'line', 404
-    store_lex "$past", $P1367
+    store_lex "$past", $P1374
 .annotate 'line', 394
-    .return ($P1367)
+    .return ($P1374)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "assertion:sym<[>"  :subid("82_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1409
-.annotate 'line', 422
-    .const 'Sub' $P1444 = "83_1278500533.96053" 
-    capture_lex $P1444
-    new $P1408, 'ExceptionHandler'
-    set_addr $P1408, control_1407
-    $P1408."handle_types"(.CONTROL_RETURN)
-    push_eh $P1408
-    .lex "self", self
-    .lex "$/", param_1409
-.annotate 'line', 423
-    new $P1410, "Undef"
-    .lex "$clist", $P1410
-.annotate 'line', 424
-    new $P1411, "Undef"
-    .lex "$past", $P1411
-.annotate 'line', 433
-    new $P1412, "Undef"
-    .lex "$i", $P1412
-.annotate 'line', 434
-    new $P1413, "Undef"
-    .lex "$n", $P1413
-.annotate 'line', 423
-    find_lex $P1414, "$/"
-    unless_null $P1414, vivify_331
-    $P1414 = root_new ['parrot';'Hash']
-  vivify_331:
-    set $P1415, $P1414["cclass_elem"]
-    unless_null $P1415, vivify_332
-    new $P1415, "Undef"
-  vivify_332:
-    store_lex "$clist", $P1415
-.annotate 'line', 424
-    find_lex $P1416, "$clist"
-    unless_null $P1416, vivify_333
-    $P1416 = root_new ['parrot';'ResizablePMCArray']
-  vivify_333:
-    set $P1417, $P1416[0]
-    unless_null $P1417, vivify_334
-    new $P1417, "Undef"
-  vivify_334:
-    $P1418 = $P1417."ast"()
-    store_lex "$past", $P1418
-.annotate 'line', 425
-    find_lex $P1422, "$past"
-    $P1423 = $P1422."negate"()
-    if $P1423, if_1421
-    set $P1420, $P1423
-    goto if_1421_end
-  if_1421:
-    find_lex $P1424, "$past"
-    $S1425 = $P1424."pasttype"()
-    iseq $I1426, $S1425, "subrule"
-    new $P1420, 'Integer'
-    set $P1420, $I1426
-  if_1421_end:
-    unless $P1420, if_1419_end
+.sub "assertion:sym<[>"  :subid("81_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1385
+.annotate 'line', 415
+    .const 'Sub' $P1420 = "82_1279529222.65073" 
+    capture_lex $P1420
+    new $P1384, 'ExceptionHandler'
+    set_addr $P1384, control_1383
+    $P1384."handle_types"(.CONTROL_RETURN)
+    push_eh $P1384
+    .lex "self", self
+    .lex "$/", param_1385
+.annotate 'line', 416
+    new $P1386, "Undef"
+    .lex "$clist", $P1386
+.annotate 'line', 417
+    new $P1387, "Undef"
+    .lex "$past", $P1387
 .annotate 'line', 426
-    find_lex $P1427, "$past"
-    $P1427."subtype"("zerowidth")
+    new $P1388, "Undef"
+    .lex "$i", $P1388
 .annotate 'line', 427
-    get_hll_global $P1428, ["PAST"], "Regex"
-    find_lex $P1429, "$past"
-.annotate 'line', 429
-    get_hll_global $P1430, ["PAST"], "Regex"
-    $P1431 = $P1430."new"("charclass" :named("pasttype"), "." :named("subtype"))
-    find_lex $P1432, "$/"
-    $P1433 = $P1428."new"($P1429, $P1431, $P1432 :named("node"))
+    new $P1389, "Undef"
+    .lex "$n", $P1389
+.annotate 'line', 416
+    find_lex $P1390, "$/"
+    unless_null $P1390, vivify_324
+    $P1390 = root_new ['parrot';'Hash']
+  vivify_324:
+    set $P1391, $P1390["cclass_elem"]
+    unless_null $P1391, vivify_325
+    new $P1391, "Undef"
+  vivify_325:
+    store_lex "$clist", $P1391
+.annotate 'line', 417
+    find_lex $P1392, "$clist"
+    unless_null $P1392, vivify_326
+    $P1392 = root_new ['parrot';'ResizablePMCArray']
+  vivify_326:
+    set $P1393, $P1392[0]
+    unless_null $P1393, vivify_327
+    new $P1393, "Undef"
+  vivify_327:
+    $P1394 = $P1393."ast"()
+    store_lex "$past", $P1394
+.annotate 'line', 418
+    find_lex $P1398, "$past"
+    $P1399 = $P1398."negate"()
+    if $P1399, if_1397
+    set $P1396, $P1399
+    goto if_1397_end
+  if_1397:
+    find_lex $P1400, "$past"
+    $S1401 = $P1400."pasttype"()
+    iseq $I1402, $S1401, "subrule"
+    new $P1396, 'Integer'
+    set $P1396, $I1402
+  if_1397_end:
+    unless $P1396, if_1395_end
+.annotate 'line', 419
+    find_lex $P1403, "$past"
+    $P1403."subtype"("zerowidth")
+.annotate 'line', 420
+    get_hll_global $P1404, ["PAST"], "Regex"
+    find_lex $P1405, "$past"
+.annotate 'line', 422
+    get_hll_global $P1406, ["PAST"], "Regex"
+    $P1407 = $P1406."new"("charclass" :named("pasttype"), "." :named("subtype"))
+    find_lex $P1408, "$/"
+    $P1409 = $P1404."new"($P1405, $P1407, $P1408 :named("node"))
+.annotate 'line', 420
+    store_lex "$past", $P1409
+  if_1395_end:
+.annotate 'line', 426
+    new $P1410, "Integer"
+    assign $P1410, 1
+    store_lex "$i", $P1410
 .annotate 'line', 427
-    store_lex "$past", $P1433
-  if_1419_end:
-.annotate 'line', 433
-    new $P1434, "Integer"
-    assign $P1434, 1
-    store_lex "$i", $P1434
-.annotate 'line', 434
-    find_lex $P1435, "$clist"
-    set $N1436, $P1435
-    new $P1437, 'Float'
-    set $P1437, $N1436
-    store_lex "$n", $P1437
-.annotate 'line', 435
-    new $P1468, 'ExceptionHandler'
-    set_addr $P1468, loop1467_handler
-    $P1468."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P1468
-  loop1467_test:
-    find_lex $P1438, "$i"
-    set $N1439, $P1438
-    find_lex $P1440, "$n"
-    set $N1441, $P1440
-    islt $I1442, $N1439, $N1441
-    unless $I1442, loop1467_done
-  loop1467_redo:
-    .const 'Sub' $P1444 = "83_1278500533.96053" 
-    capture_lex $P1444
-    $P1444()
-  loop1467_next:
-    goto loop1467_test
-  loop1467_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P1469, exception, 'type'
-    eq $P1469, .CONTROL_LOOP_NEXT, loop1467_next
-    eq $P1469, .CONTROL_LOOP_REDO, loop1467_redo
-  loop1467_done:
+    find_lex $P1411, "$clist"
+    set $N1412, $P1411
+    new $P1413, 'Float'
+    set $P1413, $N1412
+    store_lex "$n", $P1413
+.annotate 'line', 428
+    new $P1444, 'ExceptionHandler'
+    set_addr $P1444, loop1443_handler
+    $P1444."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P1444
+  loop1443_test:
+    find_lex $P1414, "$i"
+    set $N1415, $P1414
+    find_lex $P1416, "$n"
+    set $N1417, $P1416
+    islt $I1418, $N1415, $N1417
+    unless $I1418, loop1443_done
+  loop1443_redo:
+    .const 'Sub' $P1420 = "82_1279529222.65073" 
+    capture_lex $P1420
+    $P1420()
+  loop1443_next:
+    goto loop1443_test
+  loop1443_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P1445, exception, 'type'
+    eq $P1445, .CONTROL_LOOP_NEXT, loop1443_next
+    eq $P1445, .CONTROL_LOOP_REDO, loop1443_redo
+  loop1443_done:
     pop_eh 
-.annotate 'line', 446
-    find_lex $P1470, "$/"
-    find_lex $P1471, "$past"
-    $P1472 = $P1470."!make"($P1471)
-.annotate 'line', 422
-    .return ($P1472)
-  control_1407:
+.annotate 'line', 439
+    find_lex $P1446, "$/"
+    find_lex $P1447, "$past"
+    $P1448 = $P1446."!make"($P1447)
+.annotate 'line', 415
+    .return ($P1448)
+  control_1383:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1473, exception, "payload"
-    .return ($P1473)
+    getattribute $P1449, exception, "payload"
+    .return ($P1449)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1443"  :anon :subid("83_1278500533.96053") :outer("82_1278500533.96053")
-.annotate 'line', 436
-    new $P1445, "Undef"
-    .lex "$ast", $P1445
-    find_lex $P1446, "$i"
-    set $I1447, $P1446
-    find_lex $P1448, "$clist"
-    unless_null $P1448, vivify_335
-    $P1448 = root_new ['parrot';'ResizablePMCArray']
-  vivify_335:
-    set $P1449, $P1448[$I1447]
-    unless_null $P1449, vivify_336
-    new $P1449, "Undef"
-  vivify_336:
-    $P1450 = $P1449."ast"()
-    store_lex "$ast", $P1450
-.annotate 'line', 437
-    find_lex $P1452, "$ast"
-    $P1453 = $P1452."negate"()
-    if $P1453, if_1451
-.annotate 'line', 442
-    get_hll_global $P1460, ["PAST"], "Regex"
-    find_lex $P1461, "$past"
-    find_lex $P1462, "$ast"
-    find_lex $P1463, "$/"
-    $P1464 = $P1460."new"($P1461, $P1462, "alt" :named("pasttype"), $P1463 :named("node"))
-    store_lex "$past", $P1464
-.annotate 'line', 441
-    goto if_1451_end
-  if_1451:
-.annotate 'line', 438
-    find_lex $P1454, "$ast"
-    $P1454."subtype"("zerowidth")
-.annotate 'line', 439
-    get_hll_global $P1455, ["PAST"], "Regex"
-    find_lex $P1456, "$ast"
-    find_lex $P1457, "$past"
-    find_lex $P1458, "$/"
-    $P1459 = $P1455."new"($P1456, $P1457, "concat" :named("pasttype"), $P1458 :named("node"))
-    store_lex "$past", $P1459
-  if_1451_end:
-.annotate 'line', 444
-    find_lex $P1465, "$i"
-    add $P1466, $P1465, 1
-    store_lex "$i", $P1466
+.sub "_block1419"  :anon :subid("82_1279529222.65073") :outer("81_1279529222.65073")
+.annotate 'line', 429
+    new $P1421, "Undef"
+    .lex "$ast", $P1421
+    find_lex $P1422, "$i"
+    set $I1423, $P1422
+    find_lex $P1424, "$clist"
+    unless_null $P1424, vivify_328
+    $P1424 = root_new ['parrot';'ResizablePMCArray']
+  vivify_328:
+    set $P1425, $P1424[$I1423]
+    unless_null $P1425, vivify_329
+    new $P1425, "Undef"
+  vivify_329:
+    $P1426 = $P1425."ast"()
+    store_lex "$ast", $P1426
+.annotate 'line', 430
+    find_lex $P1428, "$ast"
+    $P1429 = $P1428."negate"()
+    if $P1429, if_1427
 .annotate 'line', 435
-    .return ($P1466)
+    get_hll_global $P1436, ["PAST"], "Regex"
+    find_lex $P1437, "$past"
+    find_lex $P1438, "$ast"
+    find_lex $P1439, "$/"
+    $P1440 = $P1436."new"($P1437, $P1438, "alt" :named("pasttype"), $P1439 :named("node"))
+    store_lex "$past", $P1440
+.annotate 'line', 434
+    goto if_1427_end
+  if_1427:
+.annotate 'line', 431
+    find_lex $P1430, "$ast"
+    $P1430."subtype"("zerowidth")
+.annotate 'line', 432
+    get_hll_global $P1431, ["PAST"], "Regex"
+    find_lex $P1432, "$ast"
+    find_lex $P1433, "$past"
+    find_lex $P1434, "$/"
+    $P1435 = $P1431."new"($P1432, $P1433, "concat" :named("pasttype"), $P1434 :named("node"))
+    store_lex "$past", $P1435
+  if_1427_end:
+.annotate 'line', 437
+    find_lex $P1441, "$i"
+    add $P1442, $P1441, 1
+    store_lex "$i", $P1442
+.annotate 'line', 428
+    .return ($P1442)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "cclass_elem"  :subid("84_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1477
+.sub "cclass_elem"  :subid("83_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1453
+.annotate 'line', 442
+    .const 'Sub' $P1478 = "85_1279529222.65073" 
+    capture_lex $P1478
+    .const 'Sub' $P1462 = "84_1279529222.65073" 
+    capture_lex $P1462
+    new $P1452, 'ExceptionHandler'
+    set_addr $P1452, control_1451
+    $P1452."handle_types"(.CONTROL_RETURN)
+    push_eh $P1452
+    .lex "self", self
+    .lex "$/", param_1453
+.annotate 'line', 443
+    new $P1454, "Undef"
+    .lex "$str", $P1454
+.annotate 'line', 444
+    new $P1455, "Undef"
+    .lex "$past", $P1455
+.annotate 'line', 443
+    new $P1456, "String"
+    assign $P1456, ""
+    store_lex "$str", $P1456
+    find_lex $P1457, "$past"
+.annotate 'line', 445
+    find_lex $P1459, "$/"
+    unless_null $P1459, vivify_330
+    $P1459 = root_new ['parrot';'Hash']
+  vivify_330:
+    set $P1460, $P1459["name"]
+    unless_null $P1460, vivify_331
+    new $P1460, "Undef"
+  vivify_331:
+    if $P1460, if_1458
 .annotate 'line', 449
-    .const 'Sub' $P1502 = "86_1278500533.96053" 
-    capture_lex $P1502
-    .const 'Sub' $P1486 = "85_1278500533.96053" 
-    capture_lex $P1486
-    new $P1476, 'ExceptionHandler'
-    set_addr $P1476, control_1475
-    $P1476."handle_types"(.CONTROL_RETURN)
-    push_eh $P1476
-    .lex "self", self
-    .lex "$/", param_1477
-.annotate 'line', 450
-    new $P1478, "Undef"
-    .lex "$str", $P1478
-.annotate 'line', 451
-    new $P1479, "Undef"
-    .lex "$past", $P1479
-.annotate 'line', 450
-    new $P1480, "String"
-    assign $P1480, ""
-    store_lex "$str", $P1480
-    find_lex $P1481, "$past"
-.annotate 'line', 452
-    find_lex $P1483, "$/"
-    unless_null $P1483, vivify_337
-    $P1483 = root_new ['parrot';'Hash']
-  vivify_337:
-    set $P1484, $P1483["name"]
-    unless_null $P1484, vivify_338
-    new $P1484, "Undef"
-  vivify_338:
-    if $P1484, if_1482
-.annotate 'line', 456
-    find_lex $P1497, "$/"
-    unless_null $P1497, vivify_339
-    $P1497 = root_new ['parrot';'Hash']
-  vivify_339:
-    set $P1498, $P1497["charspec"]
-    unless_null $P1498, vivify_340
-    new $P1498, "Undef"
-  vivify_340:
-    defined $I1499, $P1498
-    unless $I1499, for_undef_341
-    iter $P1496, $P1498
-    new $P1528, 'ExceptionHandler'
-    set_addr $P1528, loop1527_handler
-    $P1528."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
-    push_eh $P1528
-  loop1527_test:
-    unless $P1496, loop1527_done
-    shift $P1500, $P1496
-  loop1527_redo:
-    .const 'Sub' $P1502 = "86_1278500533.96053" 
-    capture_lex $P1502
-    $P1502($P1500)
-  loop1527_next:
-    goto loop1527_test
-  loop1527_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P1529, exception, 'type'
-    eq $P1529, .CONTROL_LOOP_NEXT, loop1527_next
-    eq $P1529, .CONTROL_LOOP_REDO, loop1527_redo
-  loop1527_done:
+    find_lex $P1473, "$/"
+    unless_null $P1473, vivify_332
+    $P1473 = root_new ['parrot';'Hash']
+  vivify_332:
+    set $P1474, $P1473["charspec"]
+    unless_null $P1474, vivify_333
+    new $P1474, "Undef"
+  vivify_333:
+    defined $I1475, $P1474
+    unless $I1475, for_undef_334
+    iter $P1472, $P1474
+    new $P1504, 'ExceptionHandler'
+    set_addr $P1504, loop1503_handler
+    $P1504."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P1504
+  loop1503_test:
+    unless $P1472, loop1503_done
+    shift $P1476, $P1472
+  loop1503_redo:
+    .const 'Sub' $P1478 = "85_1279529222.65073" 
+    capture_lex $P1478
+    $P1478($P1476)
+  loop1503_next:
+    goto loop1503_test
+  loop1503_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P1505, exception, 'type'
+    eq $P1505, .CONTROL_LOOP_NEXT, loop1503_next
+    eq $P1505, .CONTROL_LOOP_REDO, loop1503_redo
+  loop1503_done:
     pop_eh 
-  for_undef_341:
-.annotate 'line', 481
-    get_hll_global $P1530, ["PAST"], "Regex"
-    find_lex $P1531, "$str"
-    find_lex $P1532, "$/"
-    $P1533 = $P1530."new"($P1531, "enumcharlist" :named("pasttype"), $P1532 :named("node"))
-    store_lex "$past", $P1533
-.annotate 'line', 455
-    goto if_1482_end
-  if_1482:
-.annotate 'line', 452
-    .const 'Sub' $P1486 = "85_1278500533.96053" 
-    capture_lex $P1486
-    $P1486()
-  if_1482_end:
-.annotate 'line', 483
-    find_lex $P1534, "$past"
-    find_lex $P1535, "$/"
-    unless_null $P1535, vivify_353
-    $P1535 = root_new ['parrot';'Hash']
-  vivify_353:
-    set $P1536, $P1535["sign"]
-    unless_null $P1536, vivify_354
-    new $P1536, "Undef"
-  vivify_354:
-    set $S1537, $P1536
-    iseq $I1538, $S1537, "-"
-    $P1534."negate"($I1538)
-.annotate 'line', 484
-    find_lex $P1539, "$/"
-    find_lex $P1540, "$past"
-    $P1541 = $P1539."!make"($P1540)
-.annotate 'line', 449
-    .return ($P1541)
-  control_1475:
+  for_undef_334:
+.annotate 'line', 474
+    get_hll_global $P1506, ["PAST"], "Regex"
+    find_lex $P1507, "$str"
+    find_lex $P1508, "$/"
+    $P1509 = $P1506."new"($P1507, "enumcharlist" :named("pasttype"), $P1508 :named("node"))
+    store_lex "$past", $P1509
+.annotate 'line', 448
+    goto if_1458_end
+  if_1458:
+.annotate 'line', 445
+    .const 'Sub' $P1462 = "84_1279529222.65073" 
+    capture_lex $P1462
+    $P1462()
+  if_1458_end:
+.annotate 'line', 476
+    find_lex $P1510, "$past"
+    find_lex $P1511, "$/"
+    unless_null $P1511, vivify_346
+    $P1511 = root_new ['parrot';'Hash']
+  vivify_346:
+    set $P1512, $P1511["sign"]
+    unless_null $P1512, vivify_347
+    new $P1512, "Undef"
+  vivify_347:
+    set $S1513, $P1512
+    iseq $I1514, $S1513, "-"
+    $P1510."negate"($I1514)
+.annotate 'line', 477
+    find_lex $P1515, "$/"
+    find_lex $P1516, "$past"
+    $P1517 = $P1515."!make"($P1516)
+.annotate 'line', 442
+    .return ($P1517)
+  control_1451:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1542, exception, "payload"
-    .return ($P1542)
+    getattribute $P1518, exception, "payload"
+    .return ($P1518)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1501"  :anon :subid("86_1278500533.96053") :outer("84_1278500533.96053")
-    .param pmc param_1503
-.annotate 'line', 456
-    .const 'Sub' $P1509 = "87_1278500533.96053" 
-    capture_lex $P1509
-    .lex "$_", param_1503
-.annotate 'line', 457
-    find_lex $P1506, "$_"
-    unless_null $P1506, vivify_342
-    $P1506 = root_new ['parrot';'ResizablePMCArray']
-  vivify_342:
-    set $P1507, $P1506[1]
-    unless_null $P1507, vivify_343
-    new $P1507, "Undef"
-  vivify_343:
-    if $P1507, if_1505
-.annotate 'line', 479
-    find_lex $P1523, "$str"
-    find_lex $P1524, "$_"
-    unless_null $P1524, vivify_344
-    $P1524 = root_new ['parrot';'ResizablePMCArray']
-  vivify_344:
-    set $P1525, $P1524[0]
-    unless_null $P1525, vivify_345
-    new $P1525, "Undef"
-  vivify_345:
-    concat $P1526, $P1523, $P1525
-    store_lex "$str", $P1526
-    set $P1504, $P1526
-.annotate 'line', 457
-    goto if_1505_end
-  if_1505:
-    .const 'Sub' $P1509 = "87_1278500533.96053" 
-    capture_lex $P1509
-    $P1522 = $P1509()
-    set $P1504, $P1522
-  if_1505_end:
-.annotate 'line', 456
-    .return ($P1504)
+.sub "_block1477"  :anon :subid("85_1279529222.65073") :outer("83_1279529222.65073")
+    .param pmc param_1479
+.annotate 'line', 449
+    .const 'Sub' $P1485 = "86_1279529222.65073" 
+    capture_lex $P1485
+    .lex "$_", param_1479
+.annotate 'line', 450
+    find_lex $P1482, "$_"
+    unless_null $P1482, vivify_335
+    $P1482 = root_new ['parrot';'ResizablePMCArray']
+  vivify_335:
+    set $P1483, $P1482[1]
+    unless_null $P1483, vivify_336
+    new $P1483, "Undef"
+  vivify_336:
+    if $P1483, if_1481
+.annotate 'line', 472
+    find_lex $P1499, "$str"
+    find_lex $P1500, "$_"
+    unless_null $P1500, vivify_337
+    $P1500 = root_new ['parrot';'ResizablePMCArray']
+  vivify_337:
+    set $P1501, $P1500[0]
+    unless_null $P1501, vivify_338
+    new $P1501, "Undef"
+  vivify_338:
+    concat $P1502, $P1499, $P1501
+    store_lex "$str", $P1502
+    set $P1480, $P1502
+.annotate 'line', 450
+    goto if_1481_end
+  if_1481:
+    .const 'Sub' $P1485 = "86_1279529222.65073" 
+    capture_lex $P1485
+    $P1498 = $P1485()
+    set $P1480, $P1498
+  if_1481_end:
+.annotate 'line', 449
+    .return ($P1480)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1508"  :anon :subid("87_1278500533.96053") :outer("86_1278500533.96053")
-.annotate 'line', 458
-    new $P1510, "Undef"
-    .lex "$a", $P1510
-.annotate 'line', 459
-    new $P1511, "Undef"
-    .lex "$b", $P1511
-.annotate 'line', 460
-    new $P1512, "Undef"
-    .lex "$c", $P1512
-.annotate 'line', 458
-    find_lex $P1513, "$_"
-    unless_null $P1513, vivify_346
-    $P1513 = root_new ['parrot';'ResizablePMCArray']
-  vivify_346:
-    set $P1514, $P1513[0]
-    unless_null $P1514, vivify_347
-    new $P1514, "Undef"
-  vivify_347:
-    store_lex "$a", $P1514
-.annotate 'line', 459
-    find_lex $P1515, "$_"
-    unless_null $P1515, vivify_348
-    $P1515 = root_new ['parrot';'ResizablePMCArray']
-  vivify_348:
-    set $P1516, $P1515[1]
-    unless_null $P1516, vivify_349
-    $P1516 = root_new ['parrot';'ResizablePMCArray']
-  vivify_349:
-    set $P1517, $P1516[0]
-    unless_null $P1517, vivify_350
-    new $P1517, "Undef"
-  vivify_350:
-    store_lex "$b", $P1517
-.annotate 'line', 460
+.sub "_block1484"  :anon :subid("86_1279529222.65073") :outer("85_1279529222.65073")
+.annotate 'line', 451
+    new $P1486, "Undef"
+    .lex "$a", $P1486
+.annotate 'line', 452
+    new $P1487, "Undef"
+    .lex "$b", $P1487
+.annotate 'line', 453
+    new $P1488, "Undef"
+    .lex "$c", $P1488
+.annotate 'line', 451
+    find_lex $P1489, "$_"
+    unless_null $P1489, vivify_339
+    $P1489 = root_new ['parrot';'ResizablePMCArray']
+  vivify_339:
+    set $P1490, $P1489[0]
+    unless_null $P1490, vivify_340
+    new $P1490, "Undef"
+  vivify_340:
+    store_lex "$a", $P1490
+.annotate 'line', 452
+    find_lex $P1491, "$_"
+    unless_null $P1491, vivify_341
+    $P1491 = root_new ['parrot';'ResizablePMCArray']
+  vivify_341:
+    set $P1492, $P1491[1]
+    unless_null $P1492, vivify_342
+    $P1492 = root_new ['parrot';'ResizablePMCArray']
+  vivify_342:
+    set $P1493, $P1492[0]
+    unless_null $P1493, vivify_343
+    new $P1493, "Undef"
+  vivify_343:
+    store_lex "$b", $P1493
+.annotate 'line', 453
 
                              $P0 = find_lex '$a'
                              $S0 = $P0
@@ -11979,207 +12224,352 @@
                              inc $I0
                              goto cclass_loop
                            cclass_done:
-                             $P1518 = box $S2
+                             $P1494 = box $S2
                          
-    store_lex "$c", $P1518
-.annotate 'line', 477
-    find_lex $P1519, "$str"
-    find_lex $P1520, "$c"
-    concat $P1521, $P1519, $P1520
-    store_lex "$str", $P1521
-.annotate 'line', 457
-    .return ($P1521)
+    store_lex "$c", $P1494
+.annotate 'line', 470
+    find_lex $P1495, "$str"
+    find_lex $P1496, "$c"
+    concat $P1497, $P1495, $P1496
+    store_lex "$str", $P1497
+.annotate 'line', 450
+    .return ($P1497)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1485"  :anon :subid("85_1278500533.96053") :outer("84_1278500533.96053")
-.annotate 'line', 453
-    new $P1487, "Undef"
-    .lex "$name", $P1487
-    find_lex $P1488, "$/"
-    unless_null $P1488, vivify_351
-    $P1488 = root_new ['parrot';'Hash']
-  vivify_351:
-    set $P1489, $P1488["name"]
-    unless_null $P1489, vivify_352
-    new $P1489, "Undef"
-  vivify_352:
-    set $S1490, $P1489
-    new $P1491, 'String'
-    set $P1491, $S1490
-    store_lex "$name", $P1491
-.annotate 'line', 454
-    get_hll_global $P1492, ["PAST"], "Regex"
-    find_lex $P1493, "$name"
-    find_lex $P1494, "$/"
-    $P1495 = $P1492."new"($P1493, "subrule" :named("pasttype"), "method" :named("subtype"), $P1494 :named("node"))
-    store_lex "$past", $P1495
-.annotate 'line', 452
-    .return ($P1495)
+.sub "_block1461"  :anon :subid("84_1279529222.65073") :outer("83_1279529222.65073")
+.annotate 'line', 446
+    new $P1463, "Undef"
+    .lex "$name", $P1463
+    find_lex $P1464, "$/"
+    unless_null $P1464, vivify_344
+    $P1464 = root_new ['parrot';'Hash']
+  vivify_344:
+    set $P1465, $P1464["name"]
+    unless_null $P1465, vivify_345
+    new $P1465, "Undef"
+  vivify_345:
+    set $S1466, $P1465
+    new $P1467, 'String'
+    set $P1467, $S1466
+    store_lex "$name", $P1467
+.annotate 'line', 447
+    get_hll_global $P1468, ["PAST"], "Regex"
+    find_lex $P1469, "$name"
+    find_lex $P1470, "$/"
+    $P1471 = $P1468."new"($P1469, "subrule" :named("pasttype"), "method" :named("subtype"), $P1470 :named("node"))
+    store_lex "$past", $P1471
+.annotate 'line', 445
+    .return ($P1471)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "mod_internal"  :subid("88_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1546
-.annotate 'line', 487
-    new $P1545, 'ExceptionHandler'
-    set_addr $P1545, control_1544
-    $P1545."handle_types"(.CONTROL_RETURN)
-    push_eh $P1545
+.sub "mod_internal"  :subid("87_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1522
+.annotate 'line', 480
+    new $P1521, 'ExceptionHandler'
+    set_addr $P1521, control_1520
+    $P1521."handle_types"(.CONTROL_RETURN)
+    push_eh $P1521
     .lex "self", self
-    .lex "$/", param_1546
-.annotate 'line', 488
-    $P1547 = root_new ['parrot';'Hash']
-    .lex "%mods", $P1547
-.annotate 'line', 489
-    new $P1548, "Undef"
-    .lex "$n", $P1548
-.annotate 'line', 488
-    get_global $P1549, "@MODIFIERS"
-    unless_null $P1549, vivify_355
-    $P1549 = root_new ['parrot';'ResizablePMCArray']
+    .lex "$/", param_1522
+.annotate 'line', 481
+    $P1523 = root_new ['parrot';'Hash']
+    .lex "%mods", $P1523
+.annotate 'line', 482
+    new $P1524, "Undef"
+    .lex "$n", $P1524
+.annotate 'line', 481
+    get_global $P1525, "@MODIFIERS"
+    unless_null $P1525, vivify_348
+    $P1525 = root_new ['parrot';'ResizablePMCArray']
+  vivify_348:
+    set $P1526, $P1525[0]
+    unless_null $P1526, vivify_349
+    new $P1526, "Undef"
+  vivify_349:
+    store_lex "%mods", $P1526
+.annotate 'line', 482
+    find_lex $P1529, "$/"
+    unless_null $P1529, vivify_350
+    $P1529 = root_new ['parrot';'Hash']
+  vivify_350:
+    set $P1530, $P1529["n"]
+    unless_null $P1530, vivify_351
+    $P1530 = root_new ['parrot';'ResizablePMCArray']
+  vivify_351:
+    set $P1531, $P1530[0]
+    unless_null $P1531, vivify_352
+    new $P1531, "Undef"
+  vivify_352:
+    set $S1532, $P1531
+    isgt $I1533, $S1532, ""
+    if $I1533, if_1528
+    new $P1538, "Integer"
+    assign $P1538, 1
+    set $P1527, $P1538
+    goto if_1528_end
+  if_1528:
+    find_lex $P1534, "$/"
+    unless_null $P1534, vivify_353
+    $P1534 = root_new ['parrot';'Hash']
+  vivify_353:
+    set $P1535, $P1534["n"]
+    unless_null $P1535, vivify_354
+    $P1535 = root_new ['parrot';'ResizablePMCArray']
+  vivify_354:
+    set $P1536, $P1535[0]
+    unless_null $P1536, vivify_355
+    new $P1536, "Undef"
   vivify_355:
-    set $P1550, $P1549[0]
-    unless_null $P1550, vivify_356
-    new $P1550, "Undef"
+    set $N1537, $P1536
+    new $P1527, 'Float'
+    set $P1527, $N1537
+  if_1528_end:
+    store_lex "$n", $P1527
+.annotate 'line', 483
+    find_lex $P1539, "$n"
+    find_lex $P1540, "$/"
+    unless_null $P1540, vivify_356
+    $P1540 = root_new ['parrot';'Hash']
   vivify_356:
-    store_lex "%mods", $P1550
-.annotate 'line', 489
-    find_lex $P1553, "$/"
-    unless_null $P1553, vivify_357
-    $P1553 = root_new ['parrot';'Hash']
+    set $P1541, $P1540["mod_ident"]
+    unless_null $P1541, vivify_357
+    $P1541 = root_new ['parrot';'Hash']
   vivify_357:
-    set $P1554, $P1553["n"]
-    unless_null $P1554, vivify_358
-    $P1554 = root_new ['parrot';'ResizablePMCArray']
+    set $P1542, $P1541["sym"]
+    unless_null $P1542, vivify_358
+    new $P1542, "Undef"
   vivify_358:
-    set $P1555, $P1554[0]
-    unless_null $P1555, vivify_359
-    new $P1555, "Undef"
+    set $S1543, $P1542
+    find_lex $P1544, "%mods"
+    unless_null $P1544, vivify_359
+    $P1544 = root_new ['parrot';'Hash']
+    store_lex "%mods", $P1544
   vivify_359:
-    set $S1556, $P1555
-    isgt $I1557, $S1556, ""
-    if $I1557, if_1552
-    new $P1562, "Integer"
-    assign $P1562, 1
-    set $P1551, $P1562
-    goto if_1552_end
-  if_1552:
-    find_lex $P1558, "$/"
-    unless_null $P1558, vivify_360
-    $P1558 = root_new ['parrot';'Hash']
-  vivify_360:
-    set $P1559, $P1558["n"]
-    unless_null $P1559, vivify_361
-    $P1559 = root_new ['parrot';'ResizablePMCArray']
-  vivify_361:
-    set $P1560, $P1559[0]
-    unless_null $P1560, vivify_362
-    new $P1560, "Undef"
-  vivify_362:
-    set $N1561, $P1560
-    new $P1551, 'Float'
-    set $P1551, $N1561
-  if_1552_end:
-    store_lex "$n", $P1551
-.annotate 'line', 490
-    find_lex $P1563, "$n"
-    find_lex $P1564, "$/"
-    unless_null $P1564, vivify_363
-    $P1564 = root_new ['parrot';'Hash']
-  vivify_363:
-    set $P1565, $P1564["mod_ident"]
-    unless_null $P1565, vivify_364
-    $P1565 = root_new ['parrot';'Hash']
-  vivify_364:
-    set $P1566, $P1565["sym"]
-    unless_null $P1566, vivify_365
-    new $P1566, "Undef"
-  vivify_365:
-    set $S1567, $P1566
-    find_lex $P1568, "%mods"
-    unless_null $P1568, vivify_366
-    $P1568 = root_new ['parrot';'Hash']
-    store_lex "%mods", $P1568
-  vivify_366:
-    set $P1568[$S1567], $P1563
-.annotate 'line', 491
-    find_lex $P1569, "$/"
-    $P1570 = $P1569."!make"(0)
-.annotate 'line', 487
-    .return ($P1570)
-  control_1544:
+    set $P1544[$S1543], $P1539
+.annotate 'line', 484
+    find_lex $P1545, "$/"
+    $P1546 = $P1545."!make"(0)
+.annotate 'line', 480
+    .return ($P1546)
+  control_1520:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P1547, exception, "payload"
+    .return ($P1547)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Actions"]
+.include "except_types.pasm"
+.sub "subrule_alias"  :subid("88_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1554
+    .param pmc param_1555
+.annotate 'line', 578
+    new $P1553, 'ExceptionHandler'
+    set_addr $P1553, control_1552
+    $P1553."handle_types"(.CONTROL_RETURN)
+    push_eh $P1553
+    .lex "self", self
+    .lex "$past", param_1554
+    .lex "$name", param_1555
+.annotate 'line', 579
+    find_lex $P1557, "$past"
+    $S1558 = $P1557."name"()
+    isgt $I1559, $S1558, ""
+    if $I1559, if_1556
+.annotate 'line', 580
+    find_lex $P1566, "$past"
+    find_lex $P1567, "$name"
+    $P1566."name"($P1567)
+    goto if_1556_end
+  if_1556:
+.annotate 'line', 579
+    find_lex $P1560, "$past"
+    find_lex $P1561, "$name"
+    concat $P1562, $P1561, "="
+    find_lex $P1563, "$past"
+    $S1564 = $P1563."name"()
+    concat $P1565, $P1562, $S1564
+    $P1560."name"($P1565)
+  if_1556_end:
+.annotate 'line', 581
+    find_lex $P1568, "$past"
+    $P1569 = $P1568."subtype"("capture")
+.annotate 'line', 578
+    .return ($P1569)
+  control_1552:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1571, exception, "payload"
-    .return ($P1571)
+    getattribute $P1570, exception, "payload"
+    .return ($P1570)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
 .include "except_types.pasm"
-.sub "subrule_alias"  :subid("89_1278500533.96053") :method :outer("11_1278500533.96053")
-    .param pmc param_1578
-    .param pmc param_1579
+.sub "named_assertion"  :subid("89_1279529222.65073") :method :outer("11_1279529222.65073")
+    .param pmc param_1574
 .annotate 'line', 584
-    new $P1577, 'ExceptionHandler'
-    set_addr $P1577, control_1576
-    $P1577."handle_types"(.CONTROL_RETURN)
-    push_eh $P1577
+    .const 'Sub' $P1607 = "90_1279529222.65073" 
+    capture_lex $P1607
+    new $P1573, 'ExceptionHandler'
+    set_addr $P1573, control_1572
+    $P1573."handle_types"(.CONTROL_RETURN)
+    push_eh $P1573
     .lex "self", self
-    .lex "$past", param_1578
-    .lex "$name", param_1579
+    .lex "$/", param_1574
 .annotate 'line', 585
-    find_lex $P1581, "$past"
-    $S1582 = $P1581."name"()
-    isgt $I1583, $S1582, ""
-    if $I1583, if_1580
+    new $P1575, "Undef"
+    .lex "$name", $P1575
 .annotate 'line', 586
-    find_lex $P1590, "$past"
-    find_lex $P1591, "$name"
-    $P1590."name"($P1591)
-    goto if_1580_end
-  if_1580:
+    new $P1576, "Undef"
+    .lex "$past", $P1576
 .annotate 'line', 585
-    find_lex $P1584, "$past"
-    find_lex $P1585, "$name"
-    concat $P1586, $P1585, "="
-    find_lex $P1587, "$past"
-    $S1588 = $P1587."name"()
-    concat $P1589, $P1586, $S1588
-    $P1584."name"($P1589)
-  if_1580_end:
-.annotate 'line', 587
-    find_lex $P1592, "$past"
-    $P1593 = $P1592."subtype"("capture")
+    find_lex $P1577, "$/"
+    unless_null $P1577, vivify_360
+    $P1577 = root_new ['parrot';'Hash']
+  vivify_360:
+    set $P1578, $P1577["longname"]
+    unless_null $P1578, vivify_361
+    new $P1578, "Undef"
+  vivify_361:
+    set $S1579, $P1578
+    new $P1580, 'String'
+    set $P1580, $S1579
+    store_lex "$name", $P1580
+.annotate 'line', 586
+    get_hll_global $P1581, ["PAST"], "Regex"
+    find_lex $P1582, "$name"
+    find_lex $P1583, "$name"
+    find_lex $P1584, "$/"
+    $P1585 = $P1581."new"($P1582, $P1583 :named("name"), "subrule" :named("pasttype"), "capture" :named("subtype"), $P1584 :named("node"))
+    store_lex "$past", $P1585
+.annotate 'line', 588
+    find_lex $P1587, "$/"
+    unless_null $P1587, vivify_362
+    $P1587 = root_new ['parrot';'Hash']
+  vivify_362:
+    set $P1588, $P1587["nibbler"]
+    unless_null $P1588, vivify_363
+    new $P1588, "Undef"
+  vivify_363:
+    if $P1588, if_1586
+.annotate 'line', 591
+    find_lex $P1596, "$/"
+    unless_null $P1596, vivify_364
+    $P1596 = root_new ['parrot';'Hash']
+  vivify_364:
+    set $P1597, $P1596["arglist"]
+    unless_null $P1597, vivify_365
+    new $P1597, "Undef"
+  vivify_365:
+    unless $P1597, if_1595_end
+.annotate 'line', 592
+    find_lex $P1599, "$/"
+    unless_null $P1599, vivify_366
+    $P1599 = root_new ['parrot';'Hash']
+  vivify_366:
+    set $P1600, $P1599["arglist"]
+    unless_null $P1600, vivify_367
+    $P1600 = root_new ['parrot';'ResizablePMCArray']
+  vivify_367:
+    set $P1601, $P1600[0]
+    unless_null $P1601, vivify_368
+    new $P1601, "Undef"
+  vivify_368:
+    $P1602 = $P1601."ast"()
+    $P1603 = $P1602."list"()
+    defined $I1604, $P1603
+    unless $I1604, for_undef_369
+    iter $P1598, $P1603
+    new $P1613, 'ExceptionHandler'
+    set_addr $P1613, loop1612_handler
+    $P1613."handle_types"(.CONTROL_LOOP_NEXT, .CONTROL_LOOP_REDO, .CONTROL_LOOP_LAST)
+    push_eh $P1613
+  loop1612_test:
+    unless $P1598, loop1612_done
+    shift $P1605, $P1598
+  loop1612_redo:
+    .const 'Sub' $P1607 = "90_1279529222.65073" 
+    capture_lex $P1607
+    $P1607($P1605)
+  loop1612_next:
+    goto loop1612_test
+  loop1612_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P1614, exception, 'type'
+    eq $P1614, .CONTROL_LOOP_NEXT, loop1612_next
+    eq $P1614, .CONTROL_LOOP_REDO, loop1612_redo
+  loop1612_done:
+    pop_eh 
+  for_undef_369:
+  if_1595_end:
+.annotate 'line', 591
+    goto if_1586_end
+  if_1586:
+.annotate 'line', 589
+    find_lex $P1589, "$past"
+    find_lex $P1590, "$/"
+    unless_null $P1590, vivify_370
+    $P1590 = root_new ['parrot';'Hash']
+  vivify_370:
+    set $P1591, $P1590["nibbler"]
+    unless_null $P1591, vivify_371
+    $P1591 = root_new ['parrot';'ResizablePMCArray']
+  vivify_371:
+    set $P1592, $P1591[0]
+    unless_null $P1592, vivify_372
+    new $P1592, "Undef"
+  vivify_372:
+    $P1593 = $P1592."ast"()
+    $P1594 = "buildsub"($P1593)
+    $P1589."push"($P1594)
+  if_1586_end:
+.annotate 'line', 588
+    find_lex $P1615, "$past"
 .annotate 'line', 584
-    .return ($P1593)
-  control_1576:
+    .return ($P1615)
+  control_1572:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P1594, exception, "payload"
-    .return ($P1594)
+    getattribute $P1616, exception, "payload"
+    .return ($P1616)
+.end
+
+
+.namespace ["Regex";"P6Regex";"Actions"]
+.sub "_block1606"  :anon :subid("90_1279529222.65073") :outer("89_1279529222.65073")
+    .param pmc param_1608
+.annotate 'line', 592
+    .lex "$_", param_1608
+    find_lex $P1609, "$past"
+    find_lex $P1610, "$_"
+    $P1611 = $P1609."push"($P1610)
+    .return ($P1611)
 .end
 
 
 .namespace ["Regex";"P6Regex";"Actions"]
-.sub "_block1596" :load :anon :subid("90_1278500533.96053")
+.sub "_block1618" :load :anon :subid("91_1279529222.65073")
 .annotate 'line', 4
-    .const 'Sub' $P1598 = "11_1278500533.96053" 
-    $P1599 = $P1598()
-    .return ($P1599)
+    .const 'Sub' $P1620 = "11_1279529222.65073" 
+    $P1621 = $P1620()
+    .return ($P1621)
 .end
 
 
 .namespace []
-.sub "_block1602" :load :anon :subid("91_1278500533.96053")
+.sub "_block1624" :load :anon :subid("92_1279529222.65073")
 .annotate 'line', 1
-    .const 'Sub' $P1604 = "10_1278500533.96053" 
-    $P1605 = $P1604()
-    .return ($P1605)
+    .const 'Sub' $P1626 = "10_1279529222.65073" 
+    $P1627 = $P1626()
+    .return ($P1627)
 .end
 
 # .include 'src/cheats/p6regex-grammar.pir'

Modified: trunk/ext/nqp-rx/src/stage0/Regex-s0.pir
==============================================================================
--- trunk/ext/nqp-rx/src/stage0/Regex-s0.pir	Mon Jul 19 07:59:55 2010	(r48109)
+++ trunk/ext/nqp-rx/src/stage0/Regex-s0.pir	Mon Jul 19 09:38:32 2010	(r48110)
@@ -42,7 +42,7 @@
     load_bytecode 'P6object.pbc'
     .local pmc p6meta
     p6meta = new 'P6metaclass'
-    $P0 = p6meta.'new_class'('Regex::Cursor', 'attr'=>'$!target $!from $!pos $!match $!names $!debug @!bstack @!cstack @!caparray')
+    $P0 = p6meta.'new_class'('Regex::Cursor', 'attr'=>'$!target $!from $!pos $!match $!names $!debug @!bstack @!cstack @!caparray &!regex')
     $P0 = box 0
     set_global '$!generation', $P0
     $P0 = new ['Boolean']
@@ -232,6 +232,20 @@
 .end
 
 
+=item next()
+
+Return the next match from a successful Cursor.
+
+=cut
+
+.sub 'next' :method
+    .local pmc cur, match
+    cur = self.'!cursor_next'()
+    match = cur.'MATCH'()
+    .return (match)
+.end
+
+
 =item pos()
 
 Return the cursor's current position.
@@ -319,6 +333,10 @@
     parrotclass = getattribute $P0, 'parrotclass'
     cur = new parrotclass
 
+    .local pmc regex
+    regex = getattribute self, '&!regex'
+    unless null regex goto cursor_restart
+
     .local pmc from, target, debug
 
     from = getattribute self, '$!pos'
@@ -330,7 +348,30 @@
     debug = getattribute self, '$!debug'
     setattribute cur, '$!debug', debug
 
-    .return (cur, from, target)
+    .return (cur, from, target, 0)
+
+  cursor_restart:
+    .local pmc pos, cstack, bstack
+    from   = getattribute self, '$!from'
+    target = getattribute self, '$!target'
+    debug  = getattribute self, '$!debug'
+    cstack = getattribute self, '@!cstack'
+    bstack = getattribute self, '@!bstack'
+    pos    = box CURSOR_FAIL
+
+    setattribute cur, '$!from', from
+    setattribute cur, '$!pos', pos 
+    setattribute cur, '$!target', target
+    setattribute cur, '$!debug', debug
+    if null cstack goto cstack_done
+    cstack = clone cstack
+    setattribute cur, '@!cstack', cstack
+  cstack_done:
+    if null bstack goto bstack_done
+    bstack = clone bstack
+    setattribute cur, '@!bstack', bstack
+  bstack_done:
+    .return (cur, from, target, 1)
 .end
 
 
@@ -376,6 +417,38 @@
 .end
 
 
+=item !cursor_backtrack()
+
+Configure this cursor for backtracking via C<!cursor_next>.
+
+=cut
+
+.sub '!cursor_backtrack' :method
+    $P0 = getinterp
+    $P1 = $P0['sub';1]
+    setattribute self, '&!regex', $P1
+.end
+
+
+=item !cursor_next()
+
+Continue a regex match from where the current cursor left off.
+
+=cut
+
+.sub '!cursor_next' :method
+    .local pmc regex, cur
+    regex = getattribute self, '&!regex'
+    if null regex goto fail
+    cur = self.regex()
+    .return (cur)
+  fail:
+    cur = self.'!cursor_start'()
+    cur.'!cursor_fail'()
+    .return (cur)
+.end
+
+
 =item !cursor_caparray(caparray :slurpy)
 
 Set the list of subcaptures that produce arrays to C<caparray>.
@@ -2434,13 +2507,15 @@
     goto iter_loop
   iter_done:
 
-    .local pmc startlabel, donelabel, faillabel
+    .local pmc startlabel, donelabel, faillabel, restartlabel
     $S0 = concat prefix, 'start'
     startlabel = self.'post_new'('Label', 'result'=>$S0)
     $S0 = concat prefix, 'done'
     donelabel = self.'post_new'('Label', 'result'=>$S0)
     $S0 = concat prefix, 'fail'
     faillabel = self.'post_new'('Label', 'result'=>$S0)
+    $S0 = concat prefix, 'restart'
+    restartlabel = self.'post_new'('Label', 'result'=>$S0)
     reghash['fail'] = faillabel
 
     # If capnames is available, it's a hash where each key is the
@@ -2490,9 +2565,8 @@
     concat $S0, pos
     concat $S0, ', '
     concat $S0, tgt
-    concat $S0, ')'
+    concat $S0, ', $I10)'
     ops.'push_pirop'('callmethod', '"!cursor_start"', 'self', 'result'=>$S0)
-    self.'!cursorop'(ops, '!cursor_debug', 0, '"START "', regexname_esc)
     unless caparray goto caparray_skip
     self.'!cursorop'(ops, '!cursor_caparray', 0, caparray :flat)
   caparray_skip:
@@ -2518,9 +2592,13 @@
     ops.'push_pirop'('sub', off, pos, 1, 'result'=>off)
     ops.'push_pirop'('substr', tgt, tgt, off, 'result'=>tgt)
     ops.'push'(startlabel)
+    ops.'push_pirop'('eq', '$I10', 1, restartlabel)
+    self.'!cursorop'(ops, '!cursor_debug', 0, '"START "', regexname_esc)
 
     $P0 = self.'post_regex'(node)
     ops.'push'($P0)
+    ops.'push'(restartlabel)
+    self.'!cursorop'(ops, '!cursor_debug', 0, '"NEXT "', regexname_esc)
     ops.'push'(faillabel)
     self.'!cursorop'(ops, '!mark_fail', 4, rep, pos, '$I10', '$P10', 0)
     ops.'push_pirop'('lt', pos, CURSOR_FAIL, donelabel)
@@ -3160,6 +3238,13 @@
     ops.'push_pirop'('inline', 'inline'=>'  # rx pass')
     self.'!cursorop'(ops, '!cursor_pass', 0, pos, regexname)
     self.'!cursorop'(ops, '!cursor_debug', 0, '"PASS  "', regexname, '" at pos="', pos)
+
+    .local string backtrack
+    backtrack = node.'backtrack'()
+    if backtrack == 'r' goto backtrack_done
+    self.'!cursorop'(ops, '!cursor_backtrack', 0)
+  backtrack_done:
+
     ops.'push_pirop'('return', cur)
     .return (ops)
 .end
@@ -3231,8 +3316,8 @@
     .local pmc cur, pos, rep, fail
     (cur, pos, rep, fail) = self.'!rxregs'('cur pos rep fail')
 
-    .local string qname
-    .local pmc ops, q1label, q2label, btreg, cpost
+    .local string qname, btreg
+    .local pmc ops, q1label, q2label, cpost
     $S0 = concat 'rxquant', backtrack
     qname = self.'unique'($S0)
     ops = self.'post_new'('Ops', 'node'=>node)
@@ -3263,8 +3348,7 @@
   if backtrack == 'f' goto frugal
 
   greedy:
-    btreg = self.'uniquereg'('I')
-    ops.'push_pirop'('set_addr', btreg, q2label)
+    btreg = '$I10'
     .local int needmark
     .local string peekcut
     needmark = needrep
@@ -3275,14 +3359,17 @@
   greedy_1:
     if min == 0 goto greedy_2
     unless needmark goto greedy_loop
+    ops.'push_pirop'('set_addr', btreg, q2label)
     self.'!cursorop'(ops, '!mark_push', 0, 0, CURSOR_FAIL, btreg)
     goto greedy_loop
   greedy_2:
+    ops.'push_pirop'('set_addr', btreg, q2label)
     self.'!cursorop'(ops, '!mark_push', 0, 0, pos, btreg)
   greedy_loop:
     ops.'push'(q1label)
     ops.'push'(cpost)
     unless needmark goto greedy_3
+    ops.'push_pirop'('set_addr', btreg, q2label)
     self.'!cursorop'(ops, peekcut, 1, rep, btreg)
     unless needrep goto greedy_3
     ops.'push_pirop'('inc', rep)
@@ -3291,6 +3378,7 @@
     ops.'push_pirop'('ge', rep, max, q2label)
   greedy_4:
     unless max != 1 goto greedy_5
+    ops.'push_pirop'('set_addr', btreg, q2label)
     self.'!cursorop'(ops, '!mark_push', 0, rep, pos, btreg)
     if null seppost goto greedy_4a
     ops.'push'(seppost)
@@ -3328,6 +3416,8 @@
   frugal_2a:
     unless needrep goto frugal_3
     ops.'push_pirop'('set', ireg, rep)
+    unless max > 1 goto frugal_3
+    ops.'push_pirop'('ge', rep, max, fail)
   frugal_3:
     ops.'push'(cpost)
     unless needrep goto frugal_4
@@ -3336,12 +3426,10 @@
     unless min > 1 goto frugal_5
     ops.'push_pirop'('lt', rep, min, q1label)
   frugal_5:
-    unless max > 1 goto frugal_6
-    ops.'push_pirop'('ge', rep, max, q2label)
   frugal_6:
     unless max != 1 goto frugal_7
     ops.'push_pirop'('set_addr', '$I10', q1label)
-    self.'!cursorop'(ops, '!mark_push', 0, ireg, pos, '$I10')
+    self.'!cursorop'(ops, '!mark_push', 0, rep, pos, '$I10')
   frugal_7:
     ops.'push'(q2label)
     .return (ops)
@@ -3460,8 +3548,9 @@
     negate = node.'negate'()
     testop = self.'??!!'(negate, 'if', 'unless')
 
-    .local pmc subtype
+    .local pmc subtype, backtrack
     subtype = node.'subtype'()
+    backtrack = node.'backtrack'()
 
     ops.'push_pirop'('inline', subpost, subtype, negate, 'inline'=>"  # rx subrule %0 subtype=%1 negate=%2")
 
@@ -3470,8 +3559,27 @@
     ops.'push_pirop'('callmethod', subpost, cur, posargs :flat, namedargs :flat, 'result'=>'$P10')
     ops.'push_pirop'(testop, '$P10', fail)
     if subtype == 'zerowidth' goto done
+    if backtrack != 'r' goto subrule_backtrack
     if subtype == 'method' goto subrule_pos
     self.'!cursorop'(ops, '!mark_push', 0, 0, CURSOR_FAIL, 0, '$P10')
+    goto subrule_named
+  subrule_backtrack:
+    .local string rxname
+    .local pmc backlabel, passlabel
+    rxname = self.'unique'('rxsubrule')
+    $S0 = concat rxname, '_back'
+    backlabel = self.'post_new'('Label', 'result'=>$S0)
+    $S0 = concat rxname, '_pass'
+    passlabel = self.'post_new'('Label', 'result'=>$S0)
+    ops.'push_pirop'('goto', passlabel)
+    ops.'push'(backlabel)
+    ops.'push_pirop'('callmethod', '"!cursor_next"', '$P10', 'result'=>'$P10')
+    ops.'push_pirop'(testop, '$P10', fail)
+    ops.'push'(passlabel)
+    ops.'push_pirop'('set_addr', '$I10', backlabel)
+    self.'!cursorop'(ops, '!mark_push', 0, 0, pos, '$I10', '$P10')
+    if subtype == 'method' goto subrule_pos
+  subrule_named:
     ops.'push'(name)
     ops.'push_pirop'('callmethod', '"!cursor_names"', '$P10', name)
   subrule_pos:


More information about the parrot-commits mailing list