diff --git a/src/ops/bit.ops b/src/ops/bit.ops
index 24a63c5..c0c27ec 100644
--- a/src/ops/bit.ops
+++ b/src/ops/bit.ops
@@ -52,11 +52,11 @@ from $2 and $3.
 
 =cut
 
-inline op band(inout INT, in INT) :base_core {
+inline op band(inout INT, in INT) {
     $1 &= $2;
 }
 
-inline op band(out INT, in INT, in INT) :base_core {
+inline op band(out INT, in INT, in INT) {
     $1 = $2 & $3;
 }
 
@@ -74,11 +74,11 @@ from $2 and $3.
 
 =cut
 
-inline op bor(inout INT, in INT) :base_core {
+inline op bor(inout INT, in INT) {
     $1 |= $2;
 }
 
-inline op bor(out INT, in INT, in INT) :base_core {
+inline op bor(out INT, in INT, in INT) {
     $1 = $2 | $3;
 }
 
@@ -94,11 +94,11 @@ Set $1 to the value of $2 shifted left by $3 bits.
 
 =cut
 
-inline op shl(inout INT, in INT) :base_core {
+inline op shl(inout INT, in INT) {
     $1 = bit_shift_left($1, $2);
 }
 
-inline op shl(out INT, in INT, in INT) :base_core {
+inline op shl(out INT, in INT, in INT) {
     $1 = bit_shift_left($2, $3);
 }
 
@@ -114,12 +114,12 @@ Set $1 to the value of $2 shifted right by $3 bits.
 
 =cut
 
-inline op shr(inout INT, in INT) :base_core {
+inline op shr(inout INT, in INT) {
     const INTVAL signed_shift = -$2;
     $1 = bit_shift_left($1, signed_shift);
 }
 
-inline op shr(out INT, in INT, in INT) :base_core {
+inline op shr(out INT, in INT, in INT) {
     const INTVAL signed_shift = -$3;
     $1 = bit_shift_left($2, signed_shift);
 }
@@ -136,13 +136,13 @@ Set $1 to the value of $2 logically shifted right by $3 bits.
 
 =cut
 
-inline op lsr(out INT, in INT) :base_core {
+inline op lsr(out INT, in INT) {
     const UINTVAL a = (UINTVAL)$1;
     const UINTVAL b = a >> $2;
     $1 = (INTVAL)b;
 }
 
-inline op lsr(out INT, in INT, in INT) :base_core {
+inline op lsr(out INT, in INT, in INT) {
     $1 = (INTVAL)((UINTVAL)$2 >> $3);
 }
 
@@ -160,11 +160,11 @@ from $2 and $3.
 
 =cut
 
-inline op bxor(inout INT, in INT) :base_core {
+inline op bxor(inout INT, in INT) {
     $1 ^= $2;
 }
 
-inline op bxor(out INT, in INT, in INT) :base_core {
+inline op bxor(out INT, in INT, in INT) {
     $1 = $2 ^ $3;
 }
 
diff --git a/src/ops/cmp.ops b/src/ops/cmp.ops
index 7702267..7638f7c 100644
--- a/src/ops/cmp.ops
+++ b/src/ops/cmp.ops
@@ -64,31 +64,31 @@ B<eq_addr> compares the address of the objects or strings.
 
 =cut
 
-inline op eq(in INT, in INT, inconst LABEL) :base_core {
+inline op eq(in INT, in INT, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
 }
 
-inline op eq(in NUM, in NUM, inconst LABEL) :base_core {
+inline op eq(in NUM, in NUM, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
 }
 
-op eq(in STR, in STR, inconst LABEL) :base_core {
+op eq(in STR, in STR, inconst LABEL) {
     if (STRING_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_is_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq(invar PMC, in INT, inconst LABEL) :base_core {
+op eq(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -100,7 +100,7 @@ op eq(invar PMC, in INT, inconst LABEL) :base_core {
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op eq(invar PMC, in NUM, inconst LABEL) :base_core {
+op eq(invar PMC, in NUM, inconst LABEL) {
     /*
      * the get_number and get_string should probably
      * be also replaced with code like above, as
@@ -112,31 +112,31 @@ op eq(invar PMC, in NUM, inconst LABEL) :base_core {
     }
 }
 
-op eq(invar PMC, in STR, inconst LABEL) :base_core {
+op eq(invar PMC, in STR, inconst LABEL) {
     if (STRING_equal(interp, VTABLE_get_string(interp, $1), $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_is_equal_string(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_is_equal_num(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq_addr(in STR, in STR, inconst LABEL) :base_core {
+op eq_addr(in STR, in STR, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
 }
 
-op eq_addr(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq_addr(invar PMC, invar PMC, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
@@ -170,31 +170,31 @@ Branch if $1 is not equal to $2.
 
 =cut
 
-inline op ne(in INT, in INT, inconst LABEL) :base_core {
+inline op ne(in INT, in INT, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
 }
 
-inline op ne(in NUM, in NUM, inconst LABEL) :base_core {
+inline op ne(in NUM, in NUM, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
 }
 
-op ne(in STR, in STR, inconst LABEL) :base_core {
+op ne(in STR, in STR, inconst LABEL) {
     if (!STRING_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op ne(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne(invar PMC, invar PMC, inconst LABEL) {
     if (!VTABLE_is_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op ne(invar PMC, in INT, inconst LABEL) :base_core {
+op ne(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -206,37 +206,37 @@ op ne(invar PMC, in INT, inconst LABEL) :base_core {
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op ne(invar PMC, in NUM, inconst LABEL) :base_core {
+op ne(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) != $2) {
         goto OFFSET($3);
     }
 }
 
-op ne(invar PMC, in STR, inconst LABEL) :base_core {
+op ne(invar PMC, in STR, inconst LABEL) {
     if (!STRING_equal(interp, VTABLE_get_string(interp, $1), $2)) {
         goto OFFSET($3);
     }
 }
 
-op ne_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) != 0) {
         goto OFFSET($3);
     }
 }
 
-op ne_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) != 0) {
         goto OFFSET($3);
     }
 }
 
-op ne_addr(in STR, in STR, inconst LABEL) :base_core {
+op ne_addr(in STR, in STR, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
 }
 
-op ne_addr(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne_addr(invar PMC, invar PMC, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
@@ -266,31 +266,31 @@ Branch if $1 is less than $2.
 
 =cut
 
-inline op lt(in INT, in INT, inconst LABEL) :base_core {
+inline op lt(in INT, in INT, inconst LABEL) {
     if ($1 < $2) {
         goto OFFSET($3);
     }
 }
 
-inline op lt(in NUM, in NUM, inconst LABEL) :base_core {
+inline op lt(in NUM, in NUM, inconst LABEL) {
     if ($1 < $2) {
         goto OFFSET($3);
     }
 }
 
-op lt(in STR, in STR, inconst LABEL) :base_core {
+op lt(in STR, in STR, inconst LABEL) {
     if (STRING_compare(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt(invar PMC, invar PMC, inconst LABEL) :base_core {
+op lt(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt(invar PMC, in INT, inconst LABEL) :base_core {
+op lt(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -302,25 +302,25 @@ op lt(invar PMC, in INT, inconst LABEL) :base_core {
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op lt(invar PMC, in NUM, inconst LABEL) :base_core {
+op lt(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) < $2) {
         goto OFFSET($3);
     }
 }
 
-op lt(invar PMC, in STR, inconst LABEL) :base_core {
+op lt(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op lt_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op lt_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
@@ -350,31 +350,31 @@ Branch if $1 is less than or equal to $2.
 
 =cut
 
-inline op le(in INT, in INT, inconst LABEL) :base_core {
+inline op le(in INT, in INT, inconst LABEL) {
     if ($1 <= $2) {
         goto OFFSET($3);
     }
 }
 
-inline op le(in NUM, in NUM, inconst LABEL) :base_core {
+inline op le(in NUM, in NUM, inconst LABEL) {
     if ($1 <= $2) {
         goto OFFSET($3);
     }
 }
 
-op le(in STR, in STR, inconst LABEL) :base_core {
+op le(in STR, in STR, inconst LABEL) {
     if (STRING_compare(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le(invar PMC, invar PMC, inconst LABEL) :base_core {
+op le(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le(invar PMC, in INT, inconst LABEL) :base_core {
+op le(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -386,25 +386,25 @@ op le(invar PMC, in INT, inconst LABEL) :base_core {
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op le(invar PMC, in NUM, inconst LABEL) :base_core {
+op le(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) <= $2) {
         goto OFFSET($3);
     }
 }
 
-op le(invar PMC, in STR, inconst LABEL) :base_core {
+op le(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op le_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op le_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
@@ -428,13 +428,13 @@ Branch if $1 is greater than $2.
 
 =cut
 
-op gt(invar PMC, invar PMC, inconst LABEL) :base_core {
+op gt(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) > 0) {
         goto OFFSET($3);
     }
 }
 
-op gt(invar PMC, in INT, inconst LABEL) :base_core {
+op gt(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -446,25 +446,25 @@ op gt(invar PMC, in INT, inconst LABEL) :base_core {
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op gt(invar PMC, in NUM, inconst LABEL) :base_core {
+op gt(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) > $2) {
         goto OFFSET($3);
     }
 }
 
-op gt(invar PMC, in STR, inconst LABEL) :base_core {
+op gt(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) > 0) {
         goto OFFSET($3);
     }
 }
 
-op gt_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op gt_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) > 0) {
         goto OFFSET($3);
     }
 }
 
-op gt_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op gt_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) > 0) {
         goto OFFSET($3);
     }
@@ -488,13 +488,13 @@ Branch if $1 is greater than or equal to $2.
 
 =cut
 
-op ge(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ge(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) >= 0) {
         goto OFFSET($3);
     }
 }
 
-op ge(invar PMC, in INT, inconst LABEL) :base_core {
+op ge(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -506,25 +506,25 @@ op ge(invar PMC, in INT, inconst LABEL) :base_core {
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op ge(invar PMC, in NUM, inconst LABEL) :base_core {
+op ge(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) >= $2) {
         goto OFFSET($3);
     }
 }
 
-op ge(invar PMC, in STR, inconst LABEL) :base_core {
+op ge(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) >= 0) {
         goto OFFSET($3);
     }
 }
 
-op ge_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ge_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) >= 0) {
         goto OFFSET($3);
     }
 }
 
-op ge_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ge_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) >= 0) {
         goto OFFSET($3);
     }
@@ -613,50 +613,50 @@ Sets $1 to -1 if $2 < $3, +1 if $2 > $3, and 0 otherwise.
 
 =cut
 
-inline op cmp(out INT, in INT, in INT) :base_core {
+inline op cmp(out INT, in INT, in INT) {
     $1 = $2 < $3 ? -1 :
          $2 > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, in NUM, in NUM) :base_core {
+inline op cmp(out INT, in NUM, in NUM) {
     $1 = $2 < $3 ? -1 :
          $2 > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, in STR, in STR) :base_core {
+inline op cmp(out INT, in STR, in STR) {
     $1 = STRING_compare(interp, $2, $3);
 }
 
-inline op cmp(out INT, invar PMC, invar PMC) :base_core {
+inline op cmp(out INT, invar PMC, invar PMC) {
     $1 = VTABLE_cmp(interp, $2, $3);
 }
 
-inline op cmp(out INT, invar PMC, in INT) :base_core {
+inline op cmp(out INT, invar PMC, in INT) {
     const INTVAL l = VTABLE_get_integer(interp, $2);
     $1 = l < $3 ? -1 :
          l > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, invar PMC, in NUM) :base_core {
+inline op cmp(out INT, invar PMC, in NUM) {
     const FLOATVAL l = VTABLE_get_number(interp, $2);
     $1 = l < $3 ? -1 :
          l > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, invar PMC, in STR) :base_core {
+inline op cmp(out INT, invar PMC, in STR) {
     STRING* const l = VTABLE_get_string(interp, $2);
     $1 = STRING_compare(interp, l, $3);
 }
 
-inline op cmp_str(out INT, invar PMC, invar PMC) :base_core {
+inline op cmp_str(out INT, invar PMC, invar PMC) {
     $1 = VTABLE_cmp_string(interp, $2, $3);
 }
 
-inline op cmp_num(out INT, invar PMC, invar PMC) :base_core {
+inline op cmp_num(out INT, invar PMC, invar PMC) {
     $1 = VTABLE_cmp_num(interp, $2, $3);
 }
 
@@ -668,7 +668,7 @@ are not always comparable.
 
 =cut
 
-inline op cmp_pmc(out PMC, invar PMC, invar PMC) :base_core {
+inline op cmp_pmc(out PMC, invar PMC, invar PMC) {
     $1 = VTABLE_cmp_pmc(interp, $2, $3);
 }
 
@@ -922,11 +922,11 @@ Short-circuiting logical and.  Returns $2 if it's false, else returns $3.
 
 =cut
 
-inline op and(out INT, in INT, in INT) :base_core {
+inline op and(out INT, in INT, in INT) {
     $1 = $2 ? $3 : $2;
 }
 
-inline op and(invar PMC, invar PMC, invar PMC) :base_core {
+inline op and(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_get_bool(interp, $2) ? $3 : $2;
 }
 
@@ -944,19 +944,19 @@ Set the boolean state of $1 to the opposite of the boolean state from $1.
 
 =cut
 
-inline op not(inout INT) :base_core {
+inline op not(inout INT) {
     $1 = ! $1;
 }
 
-inline op not(out INT, in INT) :base_core {
+inline op not(out INT, in INT) {
     $1 = ! $2;
 }
 
-inline op not(invar PMC) :base_core {
+inline op not(invar PMC) {
     VTABLE_set_bool(interp, $1, !VTABLE_get_bool(interp, $1));
 }
 
-inline op not(out PMC, invar PMC) :base_core {
+inline op not(out PMC, invar PMC) {
     const INTVAL a = ! VTABLE_get_bool(interp, $2);
     if (PMC_IS_NULL($1))
         $1 = Parrot_pmc_new(interp, Parrot_hll_get_ctx_HLL_type(interp, enum_class_Boolean));
@@ -973,11 +973,11 @@ Short-circuiting logical or.  Returns $2 if it's true, else returns $3.
 
 =cut
 
-inline op or(out INT, in INT, in INT) :base_core {
+inline op or(out INT, in INT, in INT) {
     $1 = $2 ? $2 : $3;
 }
 
-inline op or(invar PMC, invar PMC, invar PMC) :base_core {
+inline op or(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_get_bool(interp, $2) ? $2 : $3;
 }
 
@@ -992,11 +992,11 @@ returns $3 if it's true and $2 isn't, else returns false.
 
 =cut
 
-inline op xor(out INT, in INT, in INT) :base_core {
+inline op xor(out INT, in INT, in INT) {
     $1 = ($2 && ! $3) ? $2 : ($3 && ! $2) ? $3 : 0;
 }
 
-inline op xor(invar PMC, invar PMC, invar PMC) :base_core {
+inline op xor(invar PMC, invar PMC, invar PMC) {
     const INTVAL a = VTABLE_get_bool(interp, $2);
     const INTVAL b = VTABLE_get_bool(interp, $3);
     if (a && ! b)
diff --git a/src/ops/core.ops b/src/ops/core.ops
index 22c298f..27f268a 100644
--- a/src/ops/core.ops
+++ b/src/ops/core.ops
@@ -54,7 +54,7 @@ Halts the interpreter. See also B<exit>.
 
 =cut
 
-inline op end() :base_core :check_event :flow {
+inline op end() :check_event :flow {
     goto ADDRESS(0);
 }
 
@@ -83,10 +83,10 @@ file.
 
 =cut
 
-inline op noop() :base_core {
+inline op noop() {
 }
 
-inline op check_events() :base_core :flow {
+inline op check_events() :flow {
     opcode_t * const next = expr NEXT();
     Parrot_cx_check_tasks(interp, interp->scheduler);
     goto ADDRESS(next);   /* force this being a branch op */
@@ -151,7 +151,7 @@ the stack passed in $1 for later returning.
 
 =cut
 
-inline op local_branch(invar PMC, in LABEL) :base_core :check_event :flow {
+inline op local_branch(invar PMC, in LABEL) :check_event :flow {
     INTVAL return_addr;
     opcode_t * const dest = expr NEXT();
 
diff --git a/src/ops/experimental.ops b/src/ops/experimental.ops
index 88a7c89..be84031 100644
--- a/src/ops/experimental.ops
+++ b/src/ops/experimental.ops
@@ -110,7 +110,7 @@ uses the type in $4 to create and return a new PMC.
 
 =cut
 
-inline op fetch(out PMC, in PMC, in PMC, in PMC) :base_core {
+inline op fetch(out PMC, in PMC, in PMC, in PMC) {
     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -118,7 +118,7 @@ inline op fetch(out PMC, in PMC, in PMC, in PMC) :base_core {
     }
 }
 
-inline op fetch(out PMC, in PMC, in INT, in PMC) :base_core {
+inline op fetch(out PMC, in PMC, in INT, in PMC) {
     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -126,7 +126,7 @@ inline op fetch(out PMC, in PMC, in INT, in PMC) :base_core {
     }
 }
 
-inline op fetch(out PMC, in PMC, in STR, in PMC) :base_core {
+inline op fetch(out PMC, in PMC, in STR, in PMC) {
     $1 = VTABLE_get_pmc_keyed_str(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -145,7 +145,7 @@ uses the type in $4 to create and return a new PMC.
 
 =cut
 
-inline op vivify(out PMC, in PMC, in PMC, in PMC) :base_core {
+inline op vivify(out PMC, in PMC, in PMC, in PMC) {
     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -155,7 +155,7 @@ inline op vivify(out PMC, in PMC, in PMC, in PMC) :base_core {
     }
 }
 
-inline op vivify(out PMC, in PMC, in INT, in PMC) :base_core {
+inline op vivify(out PMC, in PMC, in INT, in PMC) {
     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -165,7 +165,7 @@ inline op vivify(out PMC, in PMC, in INT, in PMC) :base_core {
     }
 }
 
-inline op vivify(out PMC, in PMC, in STR, in PMC) :base_core {
+inline op vivify(out PMC, in PMC, in STR, in PMC) {
     $1 = VTABLE_get_pmc_keyed_str(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
diff --git a/src/ops/math.ops b/src/ops/math.ops
index 1a0825c..6bdadfa 100644
--- a/src/ops/math.ops
+++ b/src/ops/math.ops
@@ -45,27 +45,27 @@ Set $1 to absolute value of $2.
 
 =cut
 
-inline op abs(inout INT) :base_core {
+inline op abs(inout INT) {
     $1 = abs($1);
 }
 
-inline op abs(inout NUM) :base_core {
+inline op abs(inout NUM) {
     $1 = fabs($1);
 }
 
-inline op abs(out INT, in INT) :base_core {
+inline op abs(out INT, in INT) {
     $1 = abs($2);
 }
 
-inline op abs(out NUM, in NUM) :base_core {
+inline op abs(out NUM, in NUM) {
     $1 = fabs($2);
 }
 
-inline op abs(invar PMC) :base_core {
+inline op abs(invar PMC) {
     VTABLE_i_absolute(interp, $1);
 }
 
-inline op abs(out PMC, invar PMC) :base_core {
+inline op abs(out PMC, invar PMC) {
     $1 = VTABLE_absolute(interp, $2, $1);
 }
 
@@ -97,43 +97,43 @@ Set $1 to the sum of $2 and $3.
 
 =cut
 
-inline op add(inout INT, in INT) :base_core {
+inline op add(inout INT, in INT) {
     $1 += $2;
 }
 
-inline op add(inout NUM, in NUM) :base_core {
+inline op add(inout NUM, in NUM) {
     $1 += $2;
 }
 
-inline op add(invar PMC, invar PMC) :base_core {
+inline op add(invar PMC, invar PMC) {
     VTABLE_i_add(interp, $1, $2);
 }
 
-inline op add(invar PMC, in INT) :base_core {
+inline op add(invar PMC, in INT) {
     VTABLE_i_add_int(interp, $1, $2);
 }
 
-inline op add(invar PMC, in NUM) :base_core {
+inline op add(invar PMC, in NUM) {
     VTABLE_i_add_float(interp, $1, $2);
 }
 
-inline op add(out INT, in INT, in INT) :base_core {
+inline op add(out INT, in INT, in INT) {
     $1 = $2 + $3;
 }
 
-inline op add(out NUM, in NUM, in NUM) :base_core {
+inline op add(out NUM, in NUM, in NUM) {
     $1 = $2 + $3;
 }
 
-inline op add(invar PMC, invar PMC, invar PMC) :base_core {
+inline op add(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_add(interp, $2, $3, $1);
 }
 
-inline op add(invar PMC, invar PMC, in INT) :base_core {
+inline op add(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_add_int(interp, $2, $3, $1);
 }
 
-inline op add(invar PMC, invar PMC, in NUM) :base_core {
+inline op add(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_add_float(interp, $2, $3, $1);
 }
 
@@ -149,15 +149,15 @@ Decrease $1 by one.
 
 =cut
 
-inline op dec(inout INT) :base_core {
+inline op dec(inout INT) {
     $1--;
 }
 
-inline op dec(inout NUM) :base_core {
+inline op dec(inout NUM) {
     $1--;
 }
 
-inline op dec(invar PMC) :base_core {
+inline op dec(invar PMC) {
     VTABLE_decrement(interp, $1);
 }
 
@@ -191,7 +191,7 @@ If the denominator is zero, a 'Divide by zero' exception is thrown.
 
 =cut
 
-inline op div(inout INT, in INT) :base_core {
+inline op div(inout INT, in INT) {
     const INTVAL den = $2;
     if (den == 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -202,7 +202,7 @@ inline op div(inout INT, in INT) :base_core {
     $1 /= den;
 }
 
-inline op div(inout NUM, in NUM) :base_core {
+inline op div(inout NUM, in NUM) {
     const FLOATVAL den = $2;
     if (FLOAT_IS_ZERO(den)) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -213,18 +213,18 @@ inline op div(inout NUM, in NUM) :base_core {
     $1 /= den;
 }
 
-inline op div(invar PMC, invar PMC) :base_core {
+inline op div(invar PMC, invar PMC) {
     VTABLE_i_divide(interp, $1, $2);
 }
 
-inline op div(invar PMC, in INT) :base_core {
+inline op div(invar PMC, in INT) {
     VTABLE_i_divide_int(interp, $1, $2);
 }
 
-inline op div(invar PMC, in NUM) :base_core {
+inline op div(invar PMC, in NUM) {
     VTABLE_i_divide_float(interp, $1, $2);
 }
-inline op div(out INT, in INT, in INT) :base_core {
+inline op div(out INT, in INT, in INT) {
     const INTVAL den = $3;
     if (den == 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -235,7 +235,7 @@ inline op div(out INT, in INT, in INT) :base_core {
     $1 = $2 / den;
 }
 
-inline op div(out NUM, in NUM, in NUM) :base_core {
+inline op div(out NUM, in NUM, in NUM) {
     const FLOATVAL den = $3;
     if (FLOAT_IS_ZERO(den)) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -246,15 +246,15 @@ inline op div(out NUM, in NUM, in NUM) :base_core {
     $1 = $2 / den;
 }
 
-inline op div(invar PMC, invar PMC, invar PMC) :base_core {
+inline op div(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_divide(interp, $2, $3, $1);
 }
 
-inline op div(invar PMC, invar PMC, in INT) :base_core {
+inline op div(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_divide_int(interp, $2, $3, $1);
 }
 
-inline op div(invar PMC, invar PMC, in NUM) :base_core {
+inline op div(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_divide_float(interp, $2, $3, $1);
 }
 
@@ -287,7 +287,7 @@ If the denominator is zero, a 'Divide by zero' exception is thrown.
 
 =cut
 
-inline op fdiv(inout INT, in INT) :base_core {
+inline op fdiv(inout INT, in INT) {
     const INTVAL den = $2;
     FLOATVAL f;
 
@@ -302,7 +302,7 @@ inline op fdiv(inout INT, in INT) :base_core {
     $1 = (INTVAL)f;
 }
 
-inline op fdiv(inout NUM, in NUM) :base_core {
+inline op fdiv(inout NUM, in NUM) {
     const FLOATVAL den = $2;
 
     if (FLOAT_IS_ZERO(den)) {
@@ -314,19 +314,19 @@ inline op fdiv(inout NUM, in NUM) :base_core {
     $1 = floor($1 / den);
 }
 
-inline op fdiv(invar PMC, invar PMC) :base_core {
+inline op fdiv(invar PMC, invar PMC) {
     VTABLE_i_floor_divide(interp, $1, $2);
 }
 
-inline op fdiv(invar PMC, in INT) :base_core {
+inline op fdiv(invar PMC, in INT) {
     VTABLE_i_floor_divide_int(interp, $1, $2);
 }
 
-inline op fdiv(invar PMC, in NUM) :base_core {
+inline op fdiv(invar PMC, in NUM) {
     VTABLE_i_floor_divide_float(interp, $1, $2);
 }
 
-inline op fdiv(out INT, in INT, in INT) :base_core {
+inline op fdiv(out INT, in INT, in INT) {
     const INTVAL den = $3;
     FLOATVAL f;
 
@@ -341,7 +341,7 @@ inline op fdiv(out INT, in INT, in INT) :base_core {
     $1 = (INTVAL)f;
 }
 
-inline op fdiv(out NUM, in NUM, in NUM) :base_core {
+inline op fdiv(out NUM, in NUM, in NUM) {
     FLOATVAL den = $3;
     if (FLOAT_IS_ZERO(den)) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -352,15 +352,15 @@ inline op fdiv(out NUM, in NUM, in NUM) :base_core {
     $1 = floor($2 / den);
 }
 
-inline op fdiv(invar PMC, invar PMC, invar PMC) :base_core {
+inline op fdiv(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_floor_divide(interp, $2, $3, $1);
 }
 
-inline op fdiv(invar PMC, invar PMC, in INT) :base_core {
+inline op fdiv(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_floor_divide_int(interp, $2, $3, $1);
 }
 
-inline op fdiv(invar PMC, invar PMC, in NUM) :base_core {
+inline op fdiv(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_floor_divide_float(interp, $2, $3, $1);
 }
 
@@ -378,16 +378,16 @@ Set $1 to the smallest integral value greater than or equal to $2.
 
 =cut
 
-inline op ceil(inout NUM) :base_core {
+inline op ceil(inout NUM) {
     $1 = ceil($1);
 }
 
-inline op ceil(out INT, in NUM) :base_core {
+inline op ceil(out INT, in NUM) {
     const FLOATVAL f = ceil($2);
     $1 = (INTVAL)f;
 }
 
-inline op ceil(out NUM, in NUM) :base_core {
+inline op ceil(out NUM, in NUM) {
     $1 = ceil($2);
 }
 
@@ -405,16 +405,16 @@ Set $1 to the largest integral value less than or equal to $2.
 
 =cut
 
-inline op floor(inout NUM) :base_core {
+inline op floor(inout NUM) {
     $1 = floor($1);
 }
 
-inline op floor(out INT, in NUM) :base_core {
+inline op floor(out INT, in NUM) {
     const FLOATVAL f = floor($2);
     $1 = (INTVAL)f;
 }
 
-inline op floor(out NUM, in NUM) :base_core {
+inline op floor(out NUM, in NUM) {
     $1 = floor($2);
 }
 
@@ -430,15 +430,15 @@ Increase $1 by one.
 
 =cut
 
-inline op inc(inout INT) :base_core {
+inline op inc(inout INT) {
     $1++;
 }
 
-inline op inc(inout NUM) :base_core {
+inline op inc(inout NUM) {
     $1++;
 }
 
-inline op inc(invar PMC) :base_core {
+inline op inc(invar PMC) {
     VTABLE_increment(interp, $1);
 }
 
@@ -490,43 +490,43 @@ References:
 
 =cut
 
-op mod(inout INT, in INT) :base_core {
+op mod(inout INT, in INT) {
     $1 = Parrot_util_intval_mod($1, $2);
 }
 
-op mod(inout NUM, in NUM) :base_core {
+op mod(inout NUM, in NUM) {
     $1 = Parrot_util_floatval_mod($1, $2);
 }
 
-inline op mod(invar PMC, invar PMC) :base_core {
+inline op mod(invar PMC, invar PMC) {
     VTABLE_i_modulus(interp, $1, $2);
 }
 
-inline op mod(invar PMC, in INT) :base_core {
+inline op mod(invar PMC, in INT) {
     VTABLE_i_modulus_int(interp, $1, $2);
 }
 
-inline op mod(invar PMC, in NUM) :base_core {
+inline op mod(invar PMC, in NUM) {
     VTABLE_i_modulus_float(interp, $1, $2);
 }
 
-op mod(out INT, in INT, in INT) :base_core {
+op mod(out INT, in INT, in INT) {
     $1 = Parrot_util_intval_mod($2, $3);
 }
 
-op mod(out NUM, in NUM, in NUM) :base_core {
+op mod(out NUM, in NUM, in NUM) {
     $1 = Parrot_util_floatval_mod($2, $3);
 }
 
-inline op mod(invar PMC, invar PMC, invar PMC) :base_core {
+inline op mod(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_modulus(interp, $2, $3, $1);
 }
 
-inline op mod(invar PMC, invar PMC, in INT) :base_core {
+inline op mod(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_modulus_int(interp, $2, $3, $1);
 }
 
-inline op mod(invar PMC, invar PMC, in NUM) :base_core {
+inline op mod(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_modulus_float(interp, $2, $3, $1);
 }
 
@@ -558,43 +558,43 @@ Set $1 to the product of $2 and $3.
 
 =cut
 
-inline op mul(inout INT, in INT) :base_core {
+inline op mul(inout INT, in INT) {
     $1 *= $2;
 }
 
-inline op mul(inout NUM, in NUM) :base_core {
+inline op mul(inout NUM, in NUM) {
     $1 *= $2;
 }
 
-inline op mul(invar PMC, invar PMC) :base_core {
+inline op mul(invar PMC, invar PMC) {
     VTABLE_i_multiply(interp, $1, $2);
 }
 
-inline op mul(invar PMC, in INT) :base_core {
+inline op mul(invar PMC, in INT) {
     VTABLE_i_multiply_int(interp, $1, $2);
 }
 
-inline op mul(invar PMC, in NUM) :base_core {
+inline op mul(invar PMC, in NUM) {
     VTABLE_i_multiply_float(interp, $1, $2);
 }
 
-inline op mul(out INT, in INT, in INT) :base_core {
+inline op mul(out INT, in INT, in INT) {
     $1 = $2 * $3;
 }
 
-inline op mul(out NUM, in NUM, in NUM) :base_core {
+inline op mul(out NUM, in NUM, in NUM) {
     $1 = $2 * $3;
 }
 
-inline op mul(invar PMC, invar PMC, invar PMC) :base_core {
+inline op mul(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_multiply(interp, $2, $3, $1);
 }
 
-inline op mul(invar PMC, invar PMC, in INT) :base_core {
+inline op mul(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_multiply_int(interp, $2, $3, $1);
 }
 
-inline op mul(invar PMC, invar PMC, in NUM) :base_core {
+inline op mul(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_multiply_float(interp, $2, $3, $1);
 }
 
@@ -618,27 +618,27 @@ Set $1 to the negative of $2.
 
 =cut
 
-inline op neg(inout INT) :base_core {
+inline op neg(inout INT) {
     $1 = - $1;
 }
 
-inline op neg(inout NUM) :base_core {
+inline op neg(inout NUM) {
     $1 = - $1;
 }
 
-inline op neg(invar PMC) :base_core {
+inline op neg(invar PMC) {
     VTABLE_i_neg(interp, $1);
 }
 
-inline op neg(out INT, in INT) :base_core {
+inline op neg(out INT, in INT) {
     $1 = - $2;
 }
 
-inline op neg(out NUM, in NUM) :base_core {
+inline op neg(out NUM, in NUM) {
     $1 = - $2;
 }
 
-inline op neg(out PMC, invar PMC) :base_core {
+inline op neg(out PMC, invar PMC) {
     $1 = VTABLE_neg(interp, $2, $1);
 }
 
@@ -670,43 +670,43 @@ Set $1 to $2 minus $3.
 
 =cut
 
-inline op sub(inout INT, in INT) :base_core {
+inline op sub(inout INT, in INT) {
     $1 -= $2;
 }
 
-inline op sub(inout NUM, in NUM) :base_core {
+inline op sub(inout NUM, in NUM) {
     $1 -= $2;
 }
 
-inline op sub(invar PMC, invar PMC) :base_core {
+inline op sub(invar PMC, invar PMC) {
     VTABLE_i_subtract(interp, $1, $2);
 }
 
-inline op sub(invar PMC, in INT) :base_core {
+inline op sub(invar PMC, in INT) {
     VTABLE_i_subtract_int(interp, $1, $2);
 }
 
-inline op sub(invar PMC, in NUM) :base_core {
+inline op sub(invar PMC, in NUM) {
     VTABLE_i_subtract_float(interp, $1, $2);
 }
 
-inline op sub(out INT, in INT, in INT) :base_core {
+inline op sub(out INT, in INT, in INT) {
     $1 = $2 - $3;
 }
 
-inline op sub(out NUM, in NUM, in NUM) :base_core {
+inline op sub(out NUM, in NUM, in NUM) {
     $1 = $2 - $3;
 }
 
-inline op sub(invar PMC, invar PMC, invar PMC) :base_core {
+inline op sub(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_subtract(interp, $2, $3, $1);
 }
 
-inline op sub(invar PMC, invar PMC, in INT) :base_core {
+inline op sub(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_subtract_int(interp, $2, $3, $1);
 }
 
-inline op sub(invar PMC, invar PMC, in NUM) :base_core {
+inline op sub(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_subtract_float(interp, $2, $3, $1);
 }
 
@@ -718,7 +718,7 @@ Set $1 to the square root of $2.
 
 =cut
 
-inline op sqrt(out NUM, in NUM) :base_core {
+inline op sqrt(out NUM, in NUM) {
     $1 = sqrt((FLOATVAL)$2);
 }
 
diff --git a/src/ops/pmc.ops b/src/ops/pmc.ops
index b366adb..54e5efa 100644
--- a/src/ops/pmc.ops
+++ b/src/ops/pmc.ops
@@ -669,7 +669,7 @@ Return a new Iterator PMC $1 for aggregate $2.
 
 =cut
 
-inline op iter(out PMC, invar PMC) :base_core {
+inline op iter(out PMC, invar PMC) {
     $1 = VTABLE_get_iter(interp, $2);
 }
 
diff --git a/src/ops/set.ops b/src/ops/set.ops
index c63c52b..2a8a15e 100644
--- a/src/ops/set.ops
+++ b/src/ops/set.ops
@@ -82,78 +82,78 @@ Set $1 to $2.
 
 =cut
 
-inline op set(out INT, in INT) :base_core {
+inline op set(out INT, in INT) {
     $1 = $2;
 }
 
-inline op set(out INT, in NUM) :base_core {
+inline op set(out INT, in NUM) {
     $1 = (INTVAL)($2);
 }
 
-inline op set(out INT, in STR) :base_core {
+inline op set(out INT, in STR) {
     $1 = Parrot_str_to_int(interp, $2);
 }
 
-inline op set(out NUM, in NUM) :base_core {
+inline op set(out NUM, in NUM) {
     $1 = $2;
 }
 
-inline op set(out NUM, in INT) :base_core {
+inline op set(out NUM, in INT) {
     $1 = (FLOATVAL)$2;
 }
 
-inline op set(out NUM, in STR) :base_core {
+inline op set(out NUM, in STR) {
     $1 = Parrot_str_to_num(interp, $2);
 }
 
-inline op set(out NUM, invar PMC) :base_core {
+inline op set(out NUM, invar PMC) {
     $1 = VTABLE_get_number(interp, $2);
 }
 
-inline op set(out STR, invar PMC) :base_core {
+inline op set(out STR, invar PMC) {
     $1 = VTABLE_get_string(interp, $2);
 }
 
-inline op set(out STR, invar STR) :base_core {
+inline op set(out STR, invar STR) {
     $1 = $2;
 }
 
-inline op set(out STR, inconst STR) :base_core {
+inline op set(out STR, inconst STR) {
     $1 = $2;
 }
 
-inline op set(out STR, in INT) :base_core {
+inline op set(out STR, in INT) {
     $1 = Parrot_str_from_int(interp, $2);
 }
 
-inline op set(out STR, in NUM) :base_core {
+inline op set(out STR, in NUM) {
     $1 = Parrot_str_from_num(interp, $2);
 }
 
-inline op set(out PMC, inconst PMC) :base_core {
+inline op set(out PMC, inconst PMC) {
     $1 = $2;
 }
 
-inline op set(out PMC, invar PMC) :base_core {
+inline op set(out PMC, invar PMC) {
     $1 = $2;
 }
 
-inline op set(invar PMC, in INT) :base_core {
+inline op set(invar PMC, in INT) {
     VTABLE_set_integer_native(interp, $1, $2);
 }
 
-inline op set(invar PMC, in NUM) :base_core {
+inline op set(invar PMC, in NUM) {
     VTABLE_set_number_native(interp, $1, $2);
 }
 
-inline op set(invar PMC, invar STR) :base_core {
+inline op set(invar PMC, invar STR) {
     VTABLE_set_string_native(interp, $1, $2);
 }
 
-inline op set(invar PMC, inconst STR) :base_core {
+inline op set(invar PMC, inconst STR) {
     VTABLE_set_string_native(interp, $1, $2);
 }
-inline op set(out INT, invar PMC) :base_core {
+inline op set(out INT, invar PMC) {
     $1 = VTABLE_get_integer(interp, $2);
 }
 
@@ -194,27 +194,27 @@ reference PMC $2 refers to.
 
 =cut
 
-inline op assign(invar PMC, invar PMC) :base_core {
+inline op assign(invar PMC, invar PMC) {
     VTABLE_assign_pmc(interp, $1, $2);
 }
 
-inline op assign(invar PMC, in INT) :base_core {
+inline op assign(invar PMC, in INT) {
     VTABLE_set_integer_native(interp, $1, $2);
 }
 
-inline op assign(invar PMC, in NUM) :base_core {
+inline op assign(invar PMC, in NUM) {
     VTABLE_set_number_native(interp, $1, $2);
 }
 
-inline op assign(invar PMC, in STR) :base_core {
+inline op assign(invar PMC, in STR) {
     VTABLE_assign_string_native(interp, $1, $2);
 }
 
-inline op assign(out STR, in STR) :base_core {
+inline op assign(out STR, in STR) {
     $1 = $2;
 }
 
-inline op setref(invar PMC, invar PMC) :base_core {
+inline op setref(invar PMC, invar PMC) {
     VTABLE_set_pmc(interp, $1, $2);
 }
 
@@ -242,19 +242,19 @@ inline op deref(out PMC, invar PMC) :base_ref {
 
 =cut
 
-inline op set(invar PMC, in INTKEY, in INT) :base_core {
+inline op set(invar PMC, in INTKEY, in INT) {
     VTABLE_set_integer_keyed_int(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in INTKEY, in NUM) :base_core {
+inline op set(invar PMC, in INTKEY, in NUM) {
     VTABLE_set_number_keyed_int(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in INTKEY, in STR) :base_core {
+inline op set(invar PMC, in INTKEY, in STR) {
     VTABLE_set_string_keyed_int(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in INTKEY, invar PMC) :base_core {
+inline op set(invar PMC, in INTKEY, invar PMC) {
     VTABLE_set_pmc_keyed_int(interp, $1, $2, $3);
 }
 
@@ -278,19 +278,19 @@ inline op set(invar PMC, in INTKEY, invar PMC) :base_core {
 
 =cut
 
-inline op set(out INT, invar PMC, in INTKEY) :base_core {
+inline op set(out INT, invar PMC, in INTKEY) {
     $1 = VTABLE_get_integer_keyed_int(interp, $2, $3);
 }
 
-inline op set(out NUM, invar PMC, in INTKEY) :base_core {
+inline op set(out NUM, invar PMC, in INTKEY) {
     $1 = VTABLE_get_number_keyed_int(interp, $2, $3);
 }
 
-inline op set(out STR, invar PMC, in INTKEY) :base_core {
+inline op set(out STR, invar PMC, in INTKEY) {
     $1 = VTABLE_get_string_keyed_int(interp, $2, $3);
 }
 
-inline op set(out PMC, invar PMC, in INTKEY) :base_core {
+inline op set(out PMC, invar PMC, in INTKEY) {
     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 }
 
@@ -314,19 +314,19 @@ inline op set(out PMC, invar PMC, in INTKEY) :base_core {
 
 =cut
 
-inline op set(invar PMC, in KEY, in INT) :base_core {
+inline op set(invar PMC, in KEY, in INT) {
     VTABLE_set_integer_keyed(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in KEY, in NUM) :base_core {
+inline op set(invar PMC, in KEY, in NUM) {
     VTABLE_set_number_keyed(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in KEY, in STR) :base_core {
+inline op set(invar PMC, in KEY, in STR) {
     VTABLE_set_string_keyed(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in KEY, invar PMC) :base_core {
+inline op set(invar PMC, in KEY, invar PMC) {
     VTABLE_set_pmc_keyed(interp, $1, $2, $3);
 }
 
@@ -350,19 +350,19 @@ inline op set(invar PMC, in KEY, invar PMC) :base_core {
 
 =cut
 
-inline op set(out INT, invar PMC, in KEY) :base_core {
+inline op set(out INT, invar PMC, in KEY) {
     $1 = VTABLE_get_integer_keyed(interp, $2, $3);
 }
 
-inline op set(out NUM, invar PMC, in KEY) :base_core {
+inline op set(out NUM, invar PMC, in KEY) {
     $1 = VTABLE_get_number_keyed(interp, $2, $3);
 }
 
-inline op set(out STR, invar PMC, in KEY) :base_core {
+inline op set(out STR, invar PMC, in KEY) {
     $1 = VTABLE_get_string_keyed(interp, $2, $3);
 }
 
-inline op set(out PMC, invar PMC, in KEY) :base_core {
+inline op set(out PMC, invar PMC, in KEY) {
     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 }
 
@@ -466,19 +466,19 @@ Set register $1 to PMCNULL.
 
 =cut
 
-inline op null(out STR) :base_core {
+inline op null(out STR) {
     $1 = STRINGNULL;
 }
 
-inline op null(out INT) :base_core {
+inline op null(out INT) {
     $1 = 0;
 }
 
-inline op null(out PMC) :base_core {
+inline op null(out PMC) {
     $1 = PMCNULL;
 }
 
-inline op null(out NUM) :base_core {
+inline op null(out NUM) {
     $1 = 0;
 }
 
diff --git a/src/ops/string.ops b/src/ops/string.ops
index d3ce85f..84b7e03 100644
--- a/src/ops/string.ops
+++ b/src/ops/string.ops
@@ -46,11 +46,11 @@ If $3 is less than the negative of the length of $2, an exception is thrown.
 
 =cut
 
-inline op ord(out INT, in STR) :base_core {
+inline op ord(out INT, in STR) {
     $1 = STRING_ord(interp, $2, 0);
 }
 
-inline op ord(out INT, in STR, in INT) :base_core {
+inline op ord(out INT, in STR, in INT) {
     $1 = STRING_ord(interp, $2, $3);
 }
 
@@ -61,7 +61,7 @@ The character specified by codepoint integer $2 is returned in string $1.
 
 =cut
 
-inline op chr(out STR, in INT) :base_core {
+inline op chr(out STR, in INT) {
     STRING * const s = Parrot_str_chr(interp, (UINTVAL)$2);
     $1 = s;
 }
@@ -75,7 +75,7 @@ If $3 is negative, cut the string after -$3 characters.
 
 =cut
 
-inline op chopn(out STR, in STR, in INT) :base_core {
+inline op chopn(out STR, in STR, in INT) {
     $1 = Parrot_str_chopn(interp, $2, $3);
 }
 
@@ -96,11 +96,11 @@ Append string $3 to string $2 and place the result into string $1.
 
 =cut
 
-inline op concat(invar PMC, invar PMC) :base_core {
+inline op concat(invar PMC, invar PMC) {
     VTABLE_i_concatenate(interp, $1, $2);
 }
 
-inline op concat(invar PMC, in STR) :base_core {
+inline op concat(invar PMC, in STR) {
     VTABLE_i_concatenate_str(interp, $1, $2);
 }
 
@@ -108,11 +108,11 @@ inline op concat(out STR, in STR, in STR) :base_mem {
     $1 = Parrot_str_concat(interp, $2, $3);
 }
 
-inline op concat(invar PMC, invar PMC, in STR) :base_core {
+inline op concat(invar PMC, invar PMC, in STR) {
     $1 = VTABLE_concatenate_str(interp, $2, $3, $1);
 }
 
-inline op concat(invar PMC, invar PMC, invar PMC) :base_core {
+inline op concat(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_concatenate(interp, $2, $3, $1);
 }
 
@@ -137,7 +137,7 @@ inline op repeat(out STR, in STR, in INT) :base_mem {
     $1 = Parrot_str_repeat(interp, $2, (UINTVAL)$3);
 }
 
-inline op repeat(invar PMC, invar PMC, in INT) :base_core {
+inline op repeat(invar PMC, invar PMC, in INT) {
     if ($3 < 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
                 EXCEPTION_NEG_REPEAT,
@@ -147,7 +147,7 @@ inline op repeat(invar PMC, invar PMC, in INT) :base_core {
     $1 = VTABLE_repeat_int(interp, $2, $3, $1);
 }
 
-inline op repeat(invar PMC, invar PMC, invar PMC) :base_core {
+inline op repeat(invar PMC, invar PMC, invar PMC) {
     if (VTABLE_get_integer(interp, $3) < 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
                 EXCEPTION_NEG_REPEAT,
@@ -166,11 +166,11 @@ The C<PMC> versions are MMD operations.
 
 =cut
 
-inline op repeat(invar PMC, in INT) :base_core {
+inline op repeat(invar PMC, in INT) {
     VTABLE_i_repeat_int(interp, $1, $2);
 }
 
-inline op repeat(invar PMC, invar PMC) :base_core {
+inline op repeat(invar PMC, invar PMC) {
     VTABLE_i_repeat(interp, $1, $2);
 }
 
@@ -251,20 +251,20 @@ New $1 string returned.
 
 =cut
 
-inline op substr(out STR, in STR, in INT) :base_core {
+inline op substr(out STR, in STR, in INT) {
     const INTVAL len = Parrot_str_byte_length(interp, $2);
     $1 = STRING_substr(interp, $2, $3, len);
 }
 
-inline op substr(out STR, in STR, in INT, in INT) :base_core {
+inline op substr(out STR, in STR, in INT, in INT) {
     $1 = STRING_substr(interp, $2, $3, $4);
 }
 
-inline op substr(out STR, invar PMC, in INT, in INT) :base_core {
+inline op substr(out STR, invar PMC, in INT, in INT) {
     $1 = VTABLE_substr_str(interp, $2, $3, $4);
 }
 
-inline op replace(out STR, in STR, in INT, in INT, in STR) :base_core {
+inline op replace(out STR, in STR, in INT, in INT, in STR) {
     $1 = Parrot_str_replace(interp, $2, $3, $4, $5);
 }
 
@@ -284,11 +284,11 @@ B<index> returns "-1".
 
 =cut
 
-inline op index(out INT, in STR, in STR) :base_core {
+inline op index(out INT, in STR, in STR) {
     $1 = ($2 && $3) ? STRING_index(interp, $2, $3, 0) : -1;
 }
 
-inline op index(out INT, in STR, in STR, in INT) :base_core {
+inline op index(out INT, in STR, in STR, in INT) {
     $1 = ($2 && $3) ? STRING_index(interp, $2, $3, $4) : -1;
 }
 
@@ -308,11 +308,11 @@ see F<misc.c> for details.
 
 =cut
 
-inline op sprintf(out STR, in STR, invar PMC) :base_core {
+inline op sprintf(out STR, in STR, invar PMC) {
     $1=Parrot_psprintf(interp, $2, $3);
 }
 
-inline op sprintf(out PMC, invar PMC, invar PMC) :base_core {
+inline op sprintf(out PMC, invar PMC, invar PMC) {
     VTABLE_set_string_native(interp, $1,
         Parrot_psprintf(interp, VTABLE_get_string(interp, $2), $3));
 }
@@ -362,7 +362,7 @@ Possible values for $3 are:
 
 =cut
 
-inline op stringinfo(out INT, in STR, in INT) :base_core {
+inline op stringinfo(out INT, in STR, in INT) {
     if ($2 == NULL)
         $1 = 0;
     else {
@@ -403,7 +403,7 @@ Uppercase $2 and put the result in $1
 
 =cut
 
-inline op upcase(out STR, in STR) :base_core {
+inline op upcase(out STR, in STR) {
     $1 = Parrot_str_upcase(interp, $2);
 }
 
@@ -413,7 +413,7 @@ Downcase $2 and put the result in $1
 
 =cut
 
-inline op downcase(out STR, in STR) :base_core {
+inline op downcase(out STR, in STR) {
     $1 = Parrot_str_downcase(interp, $2);
 }
 
@@ -423,7 +423,7 @@ Titlecase $2 and put the result in $1
 
 =cut
 
-inline op titlecase(out STR, in STR) :base_core {
+inline op titlecase(out STR, in STR) {
     $1 = Parrot_str_titlecase(interp, $2);
 }
 
@@ -445,11 +445,11 @@ on regular expression, use C<PGE::Util>'s split from the standard library.
 
 =cut
 
-op join(out STR, in STR, invar PMC) :base_core {
+op join(out STR, in STR, invar PMC) {
     $1 = Parrot_str_join(interp, $2, $3);
 }
 
-op split(out PMC, in STR, in STR) :base_core {
+op split(out PMC, in STR, in STR) {
     $1 = Parrot_str_split(interp, $2, $3);
 }
 
@@ -476,15 +476,15 @@ Both functions may throw an exception on information loss.
 
 =cut
 
-op encoding(out INT, in STR) :base_core {
+op encoding(out INT, in STR) {
     $1 = Parrot_encoding_number_of_str(interp, $2);
 }
 
-op encodingname(out STR, in INT) :base_core {
+op encodingname(out STR, in INT) {
     $1 = Parrot_encoding_name(interp, $2);
 }
 
-op find_encoding(out INT, in STR) :base_core {
+op find_encoding(out INT, in STR) {
     const INTVAL n = Parrot_encoding_number(interp, $2);
     if (n < 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
diff --git a/src/ops/var.ops b/src/ops/var.ops
index 212ca34..840eef4 100644
--- a/src/ops/var.ops
+++ b/src/ops/var.ops
@@ -472,7 +472,7 @@ found.
 
 =cut
 
-inline op find_sub_not_null(out PMC, in STR) :base_core {
+inline op find_sub_not_null(out PMC, in STR) {
     opcode_t *dest = expr NEXT();
     PMC *sub = Parrot_ns_find_named_item(interp, $2, dest);