diff --git a/build.json b/build.json
index 1ac48f2..45fa003 100644
--- a/build.json
+++ b/build.json
@@ -77,6 +77,7 @@
             "crypto/fipsmodule/hmac/hmac.cc.inc",
             "crypto/fipsmodule/keccak/keccak.cc.inc",
             "crypto/fipsmodule/mldsa/mldsa.cc.inc",
+            "crypto/fipsmodule/mlkem/fips_known_values.inc",
             "crypto/fipsmodule/mlkem/mlkem.cc.inc",
             "crypto/fipsmodule/rand/ctrdrbg.cc.inc",
             "crypto/fipsmodule/rand/rand.cc.inc",
diff --git a/crypto/fipsmodule/bcm.cc b/crypto/fipsmodule/bcm.cc
index a23d312..6429566 100644
--- a/crypto/fipsmodule/bcm.cc
+++ b/crypto/fipsmodule/bcm.cc
@@ -258,7 +258,8 @@
 
   const uint8_t *expected = BORINGSSL_bcm_text_hash;
 
-  if (!check_test(expected, result, sizeof(result), "FIPS integrity test")) {
+  if (!BORINGSSL_check_test(expected, result, sizeof(result),
+                            "FIPS integrity test")) {
 #if !defined(BORINGSSL_FIPS_BREAK_TESTS)
     return 0;
 #endif
diff --git a/crypto/fipsmodule/bcm_interface.h b/crypto/fipsmodule/bcm_interface.h
index 065eec0..766aac0 100644
--- a/crypto/fipsmodule/bcm_interface.h
+++ b/crypto/fipsmodule/bcm_interface.h
@@ -492,6 +492,8 @@
   } opaque;
 };
 
+
+
 OPENSSL_EXPORT bcm_infallible BCM_mlkem768_generate_key(
     uint8_t out_encoded_public_key[BCM_MLKEM768_PUBLIC_KEY_BYTES],
     uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
@@ -501,6 +503,14 @@
     struct BCM_mlkem768_private_key *out_private_key, const uint8_t *seed,
     size_t seed_len);
 
+OPENSSL_EXPORT bcm_status BCM_mlkem768_generate_key_fips(
+    uint8_t out_encoded_public_key[BCM_MLKEM768_PUBLIC_KEY_BYTES],
+    uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
+    struct BCM_mlkem768_private_key *out_private_key);
+
+OPENSSL_EXPORT bcm_status
+BCM_mlkem768_check_fips(const struct BCM_mlkem768_private_key *private_key);
+
 OPENSSL_EXPORT bcm_infallible BCM_mlkem768_public_from_private(
     struct BCM_mlkem768_public_key *out_public_key,
     const struct BCM_mlkem768_private_key *private_key);
@@ -576,6 +586,14 @@
     uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
     struct BCM_mlkem1024_private_key *out_private_key);
 
+OPENSSL_EXPORT bcm_status BCM_mlkem1024_generate_key_fips(
+    uint8_t out_encoded_public_key[BCM_MLKEM1024_PUBLIC_KEY_BYTES],
+    uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
+    struct BCM_mlkem1024_private_key *out_private_key);
+
+OPENSSL_EXPORT bcm_status
+BCM_mlkem1024_check_fips(const struct BCM_mlkem1024_private_key *private_key);
+
 OPENSSL_EXPORT bcm_status BCM_mlkem1024_private_key_from_seed(
     struct BCM_mlkem1024_private_key *out_private_key, const uint8_t *seed,
     size_t seed_len);
diff --git a/crypto/fipsmodule/mlkem/fips_known_values.inc b/crypto/fipsmodule/mlkem/fips_known_values.inc
new file mode 100644
index 0000000..81c1b8e
--- /dev/null
+++ b/crypto/fipsmodule/mlkem/fips_known_values.inc
@@ -0,0 +1,411 @@
+const uint8_t kTestEntropy[BCM_MLKEM_SEED_BYTES] = {
+    0xc8, 0x77, 0x34, 0x04, 0xb3, 0xe5, 0x3e, 0x31, 0x7b, 0xab, 0x41,
+    0x08, 0xa8, 0x88, 0x9c, 0x90, 0xbe, 0xfb, 0x38, 0x0f, 0x63, 0x89,
+    0x70, 0xbc, 0xdc, 0x33, 0xeb, 0x2d, 0xe2, 0x99, 0x6b, 0x1a};
+
+const uint8_t kExpectedPublicKeyBytes[BCM_MLKEM768_PUBLIC_KEY_BYTES] = {
+    0xcb, 0x0b, 0x33, 0xa2, 0xac, 0xc4, 0x94, 0x56, 0x1a, 0x36, 0x1c, 0x0d,
+    0xa3, 0x57, 0x5b, 0x63, 0x6c, 0x0d, 0x1f, 0xe1, 0xa8, 0x36, 0xd5, 0x5d,
+    0x38, 0x5c, 0xac, 0xf4, 0x67, 0x39, 0x9a, 0x12, 0x5b, 0xef, 0xa1, 0x0a,
+    0x57, 0x76, 0x87, 0x83, 0xaa, 0xaf, 0x1d, 0x9c, 0xce, 0x2b, 0x78, 0x9b,
+    0x40, 0x82, 0x1e, 0x34, 0xb3, 0x55, 0x2d, 0xd0, 0x20, 0xcd, 0x5b, 0x46,
+    0x8d, 0xda, 0xb8, 0x83, 0xa8, 0xab, 0xfb, 0x36, 0x45, 0xcb, 0x40, 0xae,
+    0x69, 0x77, 0x03, 0x22, 0xa8, 0xb4, 0xaa, 0x17, 0x53, 0x90, 0x05, 0x6a,
+    0x69, 0xb9, 0xc5, 0x2d, 0xbc, 0x9a, 0x81, 0xf6, 0x2a, 0x3c, 0x57, 0x96,
+    0x8c, 0xb2, 0x72, 0xa7, 0xd4, 0x84, 0x77, 0xf9, 0x0b, 0x80, 0xe7, 0x1e,
+    0x75, 0x61, 0x0e, 0xf9, 0xb0, 0xcf, 0x4c, 0x03, 0xca, 0x30, 0x45, 0x50,
+    0x25, 0x82, 0x56, 0x02, 0xbb, 0x58, 0xab, 0x99, 0xc7, 0x8d, 0xd5, 0x37,
+    0x12, 0xc8, 0x36, 0x5b, 0x00, 0x5f, 0x91, 0xf6, 0x2d, 0x9b, 0x91, 0xc2,
+    0x3e, 0x75, 0x56, 0x83, 0xd2, 0xaa, 0xd4, 0x03, 0xcd, 0xe8, 0xe8, 0x3f,
+    0x09, 0xc1, 0x8e, 0x84, 0xb1, 0x75, 0x85, 0x06, 0xa7, 0x4a, 0x40, 0xc2,
+    0xc9, 0x90, 0xb0, 0x0f, 0x59, 0x84, 0xe5, 0xf7, 0xa8, 0xd8, 0x35, 0x33,
+    0xa5, 0x82, 0x4e, 0xf6, 0xb5, 0xaf, 0xd5, 0xaa, 0xbb, 0x52, 0x30, 0x0b,
+    0xb1, 0x67, 0x7b, 0xbb, 0xdc, 0x38, 0x58, 0xf4, 0x2f, 0xe4, 0xeb, 0x47,
+    0xf0, 0x49, 0x76, 0x45, 0x10, 0x02, 0x19, 0xa7, 0xc6, 0x1f, 0x8a, 0x71,
+    0xda, 0x51, 0x61, 0x79, 0xc4, 0x10, 0xeb, 0x3a, 0x11, 0xd9, 0x93, 0x1d,
+    0x83, 0x81, 0x48, 0x3d, 0x68, 0x35, 0xff, 0xe3, 0xa6, 0xa8, 0x40, 0x74,
+    0xdb, 0x7c, 0xb4, 0xb2, 0x05, 0x89, 0xc8, 0x09, 0x42, 0x27, 0x28, 0x55,
+    0x01, 0x57, 0xc9, 0xf9, 0xfa, 0x36, 0xd3, 0x5c, 0x51, 0x40, 0xca, 0x1e,
+    0x34, 0xc8, 0xb9, 0x27, 0xf1, 0x15, 0xc9, 0xa4, 0x18, 0x9c, 0xa8, 0x4c,
+    0x55, 0xf8, 0x4d, 0x90, 0xbc, 0x88, 0xd1, 0x46, 0x01, 0x80, 0x96, 0x54,
+    0x8d, 0x01, 0x6e, 0xe4, 0x26, 0x0c, 0x7a, 0x08, 0x3d, 0x7c, 0x26, 0x66,
+    0xb1, 0xd1, 0x15, 0xc7, 0xc0, 0x0b, 0x06, 0x92, 0x9c, 0x26, 0xa6, 0x6c,
+    0x3a, 0x46, 0x47, 0x15, 0x37, 0xb0, 0x0a, 0xc1, 0x5d, 0xe0, 0x51, 0xae,
+    0x17, 0x87, 0x2f, 0x75, 0x2c, 0x64, 0xd5, 0x39, 0x09, 0xe6, 0xd0, 0x7c,
+    0x3d, 0x79, 0x47, 0x78, 0x0a, 0x82, 0xc9, 0xba, 0x37, 0x07, 0x93, 0x94,
+    0xa4, 0x45, 0x7c, 0x07, 0x69, 0x24, 0x1d, 0xc9, 0x75, 0x41, 0x6b, 0xc1,
+    0x42, 0x28, 0x06, 0xe3, 0xfc, 0x7b, 0xd2, 0xf8, 0xbf, 0xe7, 0x5a, 0xc2,
+    0xc0, 0x81, 0x63, 0xf3, 0x84, 0x32, 0x31, 0x4a, 0x8d, 0x6b, 0xe3, 0x3e,
+    0x22, 0x67, 0x9a, 0x3a, 0x96, 0x09, 0xa6, 0xf9, 0x53, 0x40, 0x41, 0x2a,
+    0x04, 0xa7, 0xc5, 0x7b, 0x86, 0xcd, 0xed, 0xec, 0xae, 0xfd, 0xc7, 0x11,
+    0x48, 0x56, 0x77, 0x0b, 0xb7, 0xbb, 0xaf, 0xfb, 0x6c, 0x9e, 0xd6, 0x5c,
+    0xbc, 0xf7, 0x9a, 0x75, 0xb5, 0xb2, 0x20, 0xd9, 0x60, 0x90, 0x65, 0x02,
+    0xf9, 0x16, 0x34, 0xdf, 0x0b, 0x16, 0x2a, 0x97, 0x00, 0x5d, 0xc1, 0x65,
+    0xc3, 0xb9, 0x1f, 0x2e, 0x85, 0x97, 0xbd, 0xca, 0xaa, 0x1d, 0xf2, 0x4f,
+    0x74, 0xe5, 0x56, 0x94, 0xdc, 0x53, 0xbb, 0xc0, 0x75, 0x1c, 0x2b, 0x59,
+    0x6b, 0x50, 0x2c, 0x25, 0x4c, 0x78, 0xd7, 0x68, 0x40, 0x0b, 0x91, 0x7a,
+    0x93, 0x02, 0x83, 0x5e, 0x6c, 0x03, 0xc7, 0xc4, 0x24, 0x6f, 0x8b, 0xa4,
+    0x70, 0x37, 0x1f, 0xe5, 0x33, 0x59, 0xf6, 0xbb, 0x5f, 0xb8, 0x58, 0x50,
+    0x62, 0x16, 0x95, 0x2a, 0x88, 0xa3, 0xc6, 0x24, 0x94, 0x4b, 0xb0, 0x03,
+    0x8e, 0xe6, 0x50, 0xd1, 0x63, 0xa2, 0xab, 0x00, 0x16, 0xf4, 0x0a, 0x7d,
+    0xe6, 0xe0, 0xb9, 0x0c, 0xd8, 0x08, 0xae, 0xf6, 0x80, 0xb7, 0x48, 0xb8,
+    0x10, 0xd1, 0x77, 0x57, 0x48, 0x2a, 0xc1, 0xf1, 0x4e, 0x61, 0xb4, 0x06,
+    0x5a, 0xa1, 0xba, 0x32, 0x4a, 0x9a, 0xab, 0x8c, 0xa8, 0xe3, 0xa0, 0x68,
+    0x39, 0xa3, 0x25, 0x55, 0x48, 0xcd, 0x12, 0x98, 0x14, 0x1b, 0x39, 0x5b,
+    0xf4, 0x88, 0xbe, 0x5f, 0xac, 0xba, 0x18, 0x20, 0x74, 0x2c, 0xa1, 0x0b,
+    0xfc, 0xf1, 0x00, 0x85, 0x24, 0x27, 0x3d, 0x80, 0xb6, 0x30, 0x42, 0x7b,
+    0x74, 0xb0, 0xbf, 0x87, 0x51, 0x9b, 0xa8, 0x1c, 0x79, 0xbd, 0x50, 0x85,
+    0x66, 0xe1, 0x93, 0xdd, 0xc5, 0x5d, 0x5d, 0xd0, 0xbe, 0xcb, 0x90, 0x36,
+    0xf8, 0xc6, 0xc2, 0xea, 0xea, 0x40, 0xce, 0xa7, 0xb0, 0xae, 0xc5, 0x44,
+    0x3a, 0x27, 0xc5, 0x4a, 0xf0, 0x21, 0x4f, 0xf6, 0x63, 0xb1, 0x8c, 0x20,
+    0x76, 0x65, 0xb5, 0x79, 0x55, 0x10, 0xa5, 0xa7, 0x4b, 0x57, 0x96, 0xb3,
+    0x03, 0xe6, 0xa8, 0x93, 0xf5, 0xc5, 0xca, 0xe0, 0x1a, 0x23, 0x30, 0x6d,
+    0x09, 0x07, 0x81, 0x5e, 0x05, 0xc6, 0x1b, 0x7a, 0x0e, 0xde, 0xf3, 0x00,
+    0x91, 0xf3, 0xbb, 0x4b, 0xa6, 0x8e, 0x96, 0xc3, 0x3a, 0xc8, 0x72, 0x19,
+    0x23, 0x23, 0xc7, 0x94, 0x46, 0x75, 0xa2, 0xc5, 0x9e, 0xa3, 0x15, 0x86,
+    0xb4, 0xa7, 0x95, 0xda, 0x16, 0xae, 0x42, 0xe8, 0xcc, 0xf6, 0x41, 0xbc,
+    0x9c, 0xe8, 0x07, 0xc9, 0x05, 0x3c, 0x74, 0xb2, 0xad, 0x77, 0xc4, 0x08,
+    0x56, 0x78, 0xb8, 0x65, 0x2a, 0x33, 0x39, 0x82, 0x16, 0x3c, 0x2b, 0x73,
+    0x41, 0x2a, 0xbc, 0xc8, 0x36, 0x23, 0x2c, 0x23, 0x29, 0xce, 0x94, 0x8a,
+    0xba, 0x13, 0x3f, 0xfa, 0xcc, 0x6e, 0x17, 0x40, 0xb0, 0xb4, 0x9c, 0xae,
+    0xf9, 0x72, 0x40, 0xf7, 0x2a, 0xaf, 0x00, 0x17, 0x7e, 0x88, 0x44, 0x4e,
+    0x32, 0xa4, 0x80, 0x96, 0x53, 0x20, 0xe4, 0xaa, 0x18, 0x9c, 0x69, 0x63,
+    0xdb, 0x81, 0x73, 0x0e, 0x64, 0x40, 0x12, 0xc1, 0x26, 0x0e, 0xac, 0x4d,
+    0x38, 0xa6, 0x4c, 0x05, 0xeb, 0x42, 0x1f, 0x88, 0x6e, 0x6c, 0xa3, 0x98,
+    0x95, 0xc3, 0x5a, 0x31, 0xfc, 0x8a, 0x7c, 0xd6, 0xa5, 0x6c, 0x5a, 0xc9,
+    0xf5, 0xf2, 0xb0, 0xf7, 0x05, 0x8d, 0x3a, 0x0b, 0x3f, 0x4d, 0x1b, 0x0e,
+    0x38, 0x7b, 0x1c, 0xe5, 0xd0, 0x75, 0x40, 0x77, 0xc2, 0xe0, 0x8b, 0xa9,
+    0xfb, 0xa6, 0xa7, 0x13, 0xf0, 0xbc, 0x0c, 0x13, 0xb0, 0x70, 0x3a, 0x2f,
+    0x20, 0xe7, 0x38, 0xd8, 0x82, 0xa4, 0xc0, 0x06, 0x96, 0x95, 0x75, 0x5c,
+    0xbc, 0x68, 0xce, 0xee, 0xa6, 0x44, 0xbb, 0xf2, 0x62, 0x14, 0x43, 0x10,
+    0xe6, 0x0b, 0x5c, 0x66, 0x02, 0xbf, 0x38, 0xe9, 0x8f, 0x19, 0x69, 0x6c,
+    0x08, 0xfa, 0x93, 0x23, 0xf1, 0x35, 0x5f, 0x33, 0xcf, 0xe2, 0x32, 0x11,
+    0xda, 0x31, 0xbb, 0xd8, 0xf5, 0x7e, 0x55, 0xc3, 0x6a, 0xa3, 0x04, 0x8c,
+    0xef, 0x50, 0x67, 0x0f, 0xe9, 0xbb, 0x11, 0x6b, 0xca, 0x5a, 0x23, 0x15,
+    0xf7, 0x52, 0x8c, 0x69, 0xbb, 0x2d, 0x26, 0xd3, 0x78, 0x32, 0x33, 0x9b,
+    0x1d, 0x02, 0x7c, 0x22, 0x4b, 0x57, 0x19, 0xec, 0xcd, 0x16, 0x63, 0x5d,
+    0x1f, 0x0c, 0x67, 0xda, 0x6a, 0xc7, 0x2c, 0xf1, 0x0b, 0xcf, 0x92, 0x10,
+    0xcb, 0x78, 0x57, 0x67, 0x61, 0x0e, 0xb3, 0x55, 0xb0, 0x17, 0x32, 0x4e,
+    0x95, 0xf1, 0xcb, 0xb5, 0xdb, 0x5d, 0x8e, 0x38, 0x97, 0x28, 0x46, 0x1e,
+    0x37, 0x4b, 0x5c, 0x03, 0xf4, 0x84, 0x0c, 0xfc, 0x49, 0x3b, 0xd2, 0xc6,
+    0x97, 0xd4, 0x4f, 0xef, 0xe6, 0x5c, 0xb2, 0x96, 0x8e, 0xbc, 0x18, 0x9f,
+    0xec, 0x8a, 0x67, 0x53, 0xe8, 0x2a, 0x41, 0x5c, 0x6e, 0xfe, 0xca, 0x1a,
+    0xd0, 0x03, 0x4f, 0xe8, 0xd9, 0xb0, 0xe2, 0xa1, 0x6c, 0x32, 0xd5, 0x37,
+    0x68, 0x9c, 0x6b, 0x30, 0x87, 0xb4, 0x6e, 0xa8, 0xc5, 0x45, 0xe4, 0x74,
+    0x4a, 0x80, 0x02, 0x84, 0x78, 0x0e, 0x2c, 0x9c, 0x37, 0x07, 0x26, 0x31,
+    0x88, 0x0a, 0x89, 0xd2, 0xba, 0x8b, 0x09, 0xb2, 0x16, 0x7b, 0x23, 0xa8,
+    0x0c, 0x82, 0xc4, 0x22, 0xa2, 0x21, 0x2d, 0xa4, 0xa0, 0xeb, 0xe4, 0xa6,
+    0xd4, 0x16, 0xa0, 0xa7, 0x19, 0x8b, 0x8f, 0x87, 0x9b, 0x53, 0x6c, 0xba,
+    0x14, 0xa7, 0xc4, 0x64, 0x08, 0xb4, 0x68, 0xda, 0x85, 0xa6, 0x47, 0xbc,
+    0x58, 0x34, 0xcd, 0x60, 0x43, 0xad, 0x14, 0xd4, 0xca, 0xd7, 0xb1, 0x6c,
+    0xc0, 0x05, 0x68, 0xaf, 0xa7, 0x08, 0x9d, 0x6a, 0xb0, 0x70, 0x96, 0x81,
+    0xb8, 0x55, 0xbf, 0xa1, 0xcc, 0xb1, 0x37, 0xe0, 0x94, 0x42, 0x05, 0x0c,
+    0x83, 0xef, 0x6d, 0xf0, 0x4e, 0xba, 0xe6, 0x78, 0x49, 0xaf, 0x1f, 0x88,
+    0xf0, 0x18, 0x0c, 0x17, 0x66, 0x92, 0xd8, 0x50, 0x57, 0x3b, 0x8e, 0xc9,
+    0xd5, 0x8c, 0xfb, 0x9b, 0x78, 0x65, 0x01, 0x76};
+
+const uint8_t kExpectedPrivateKeyBytes[2400] = {
+    0xd8, 0xc9, 0x39, 0x7c, 0x31, 0x30, 0xd8, 0xec, 0xb4, 0x11, 0xa6, 0x8e,
+    0xfc, 0xc8, 0x9a, 0x55, 0x3c, 0xb7, 0xe6, 0x81, 0x7e, 0x02, 0x88, 0xbd,
+    0x06, 0x91, 0x60, 0x9b, 0xf5, 0x57, 0x6a, 0xf8, 0x73, 0x9e, 0x52, 0xa8,
+    0x03, 0xf0, 0x97, 0xb4, 0x22, 0xb7, 0x02, 0x23, 0xcd, 0x3e, 0xa1, 0x03,
+    0x20, 0x66, 0x6e, 0x20, 0x20, 0xcb, 0x42, 0xec, 0xb6, 0xc2, 0x14, 0x2c,
+    0xe7, 0xa8, 0x88, 0x3d, 0xd2, 0x26, 0x9c, 0xf7, 0xb3, 0x4f, 0x00, 0x27,
+    0x61, 0xc6, 0x10, 0xb2, 0x72, 0x34, 0x39, 0xf1, 0x79, 0x03, 0xcc, 0x06,
+    0xd2, 0xe4, 0x29, 0x57, 0x91, 0x2f, 0x0d, 0x45, 0x19, 0x30, 0x27, 0x47,
+    0xcc, 0xba, 0xbe, 0x19, 0x01, 0x1a, 0xbb, 0xd8, 0xcb, 0x74, 0xca, 0x4a,
+    0xfa, 0x32, 0x2f, 0xb8, 0xbb, 0x5c, 0x19, 0x2a, 0xbf, 0x31, 0x0a, 0x82,
+    0xf3, 0x29, 0x74, 0x30, 0xa4, 0x95, 0x4c, 0x42, 0x59, 0x8c, 0xb3, 0xcb,
+    0xfe, 0xa9, 0xb4, 0x2e, 0x60, 0x71, 0x64, 0x51, 0x6d, 0xf9, 0x73, 0x5b,
+    0xf5, 0x59, 0x9b, 0xf5, 0xd9, 0x9d, 0x3f, 0x86, 0x3a, 0x50, 0x6c, 0x23,
+    0x8c, 0x96, 0xc0, 0x5e, 0x7c, 0x48, 0x43, 0xec, 0x08, 0xf5, 0xf7, 0x7e,
+    0x6b, 0x54, 0x84, 0xb2, 0x6c, 0x52, 0xd5, 0x2b, 0x38, 0x85, 0xf4, 0x40,
+    0x36, 0x09, 0x2f, 0xe6, 0xd0, 0x9e, 0xe6, 0xb6, 0x96, 0x7a, 0xe1, 0xc3,
+    0xf7, 0xfa, 0x89, 0xc6, 0x75, 0x6f, 0x65, 0xea, 0x4a, 0x6d, 0x55, 0x33,
+    0xe2, 0xc6, 0x30, 0xfb, 0x7b, 0xbd, 0xcb, 0x33, 0x4d, 0xd6, 0x84, 0x1b,
+    0x28, 0x77, 0x60, 0xbf, 0x4b, 0x82, 0xd0, 0xb0, 0xc5, 0x88, 0x0c, 0x51,
+    0x00, 0x22, 0x5e, 0xd9, 0x41, 0x2e, 0x7e, 0x43, 0xa6, 0x9d, 0x34, 0x5d,
+    0x24, 0x80, 0xad, 0x7f, 0xd3, 0xae, 0xc7, 0x5a, 0x51, 0x74, 0x06, 0xc0,
+    0x6f, 0x04, 0xae, 0x9b, 0x79, 0x6e, 0x35, 0xfa, 0x0d, 0xf3, 0xda, 0xa4,
+    0xfa, 0x38, 0x4a, 0xee, 0xb3, 0xa4, 0x87, 0xa7, 0x27, 0xe2, 0x02, 0x2a,
+    0x29, 0x27, 0xcf, 0xca, 0x4a, 0x20, 0x01, 0x15, 0x3d, 0x12, 0xc7, 0xcc,
+    0x74, 0x99, 0x17, 0xa6, 0x7b, 0x04, 0xd7, 0xea, 0x64, 0x88, 0xa3, 0x54,
+    0xb5, 0xc2, 0xa3, 0xea, 0x69, 0x94, 0xb9, 0xc3, 0x45, 0xf8, 0x2b, 0x3c,
+    0xe5, 0xc1, 0x25, 0xf6, 0xc9, 0x82, 0xe3, 0x45, 0x25, 0xca, 0x71, 0x3d,
+    0x73, 0x10, 0x99, 0xa5, 0xb5, 0x79, 0xdc, 0x61, 0x8f, 0x04, 0x3c, 0x61,
+    0x6b, 0x90, 0x4d, 0x83, 0xa3, 0x0d, 0xb4, 0xba, 0xb7, 0x3b, 0x81, 0xca,
+    0xbb, 0x59, 0x16, 0x46, 0xf4, 0x75, 0x7c, 0xaa, 0x0f, 0x90, 0xec, 0x37,
+    0xa4, 0x50, 0xa8, 0x41, 0xb4, 0x33, 0xd2, 0xb7, 0x28, 0xe1, 0xda, 0x74,
+    0x36, 0x3a, 0xa6, 0x96, 0x76, 0x06, 0x67, 0xd3, 0x8e, 0xda, 0xd5, 0x29,
+    0x24, 0x1a, 0xbe, 0x82, 0x83, 0x6b, 0x3a, 0x90, 0xc1, 0x86, 0x34, 0x2d,
+    0xd8, 0xa3, 0xa5, 0x7e, 0xe6, 0xca, 0x3f, 0xc5, 0xbf, 0xba, 0x24, 0x14,
+    0xd2, 0xfc, 0x3f, 0x97, 0x8c, 0xca, 0x59, 0xa5, 0x52, 0xf1, 0x8c, 0x62,
+    0x8d, 0x8a, 0x7d, 0x1b, 0x35, 0x76, 0x79, 0x98, 0x39, 0x57, 0x53, 0x1f,
+    0x78, 0x82, 0x7d, 0xcd, 0x9c, 0xab, 0xb3, 0x12, 0x52, 0x86, 0x87, 0xbf,
+    0x01, 0x12, 0x58, 0x45, 0x37, 0x75, 0x1a, 0xe0, 0x03, 0xbd, 0x67, 0x4c,
+    0x76, 0xfa, 0x06, 0x59, 0xa2, 0x1f, 0x48, 0x73, 0x7f, 0x0c, 0x90, 0xc1,
+    0x82, 0xc0, 0x98, 0x2f, 0x6a, 0x1c, 0x6f, 0x6c, 0x98, 0x70, 0x16, 0x8e,
+    0x8c, 0x5b, 0x60, 0x92, 0x42, 0x59, 0xd6, 0xb2, 0x13, 0x7a, 0x11, 0xb6,
+    0x15, 0x1b, 0x07, 0x50, 0x52, 0x73, 0x86, 0xbc, 0x3a, 0xff, 0x66, 0x71,
+    0x57, 0xf8, 0x89, 0x7a, 0x3a, 0x95, 0xc5, 0xa1, 0x31, 0x48, 0x15, 0xc9,
+    0xe0, 0x4b, 0x41, 0xb6, 0x07, 0x5a, 0x70, 0x88, 0x11, 0xce, 0xdc, 0xa7,
+    0x84, 0x23, 0x85, 0x96, 0xd8, 0x20, 0x9f, 0x89, 0x42, 0xbc, 0x0b, 0xd0,
+    0xd9, 0x11, 0x9f, 0x2f, 0x71, 0x37, 0xa2, 0x10, 0x98, 0x95, 0xa7, 0x1f,
+    0x99, 0x48, 0x8e, 0x5b, 0x40, 0x65, 0x9f, 0x08, 0x4e, 0x04, 0x16, 0x35,
+    0xc8, 0x56, 0xa1, 0x02, 0xa1, 0xaf, 0x0e, 0x5b, 0xaf, 0x02, 0x66, 0x2e,
+    0xc8, 0xa5, 0x49, 0xe7, 0xa4, 0x6b, 0x03, 0xe2, 0x42, 0xb3, 0x37, 0x76,
+    0x2c, 0x89, 0x00, 0x76, 0x83, 0xb3, 0x93, 0xdc, 0x78, 0x56, 0xc9, 0x02,
+    0xf1, 0xd3, 0x92, 0xe5, 0x14, 0x36, 0xba, 0x37, 0x1d, 0x86, 0x87, 0x81,
+    0x5f, 0x30, 0x16, 0x7f, 0xdb, 0x76, 0xe2, 0x46, 0x3d, 0x32, 0xe8, 0x47,
+    0x35, 0x5b, 0x68, 0x39, 0x70, 0xa3, 0xc2, 0xb8, 0xb3, 0x6e, 0xd0, 0x22,
+    0x6b, 0x39, 0x9c, 0xd9, 0xa3, 0x93, 0x69, 0xbc, 0xcb, 0xe0, 0xbc, 0x82,
+    0x1b, 0xfb, 0x9f, 0x72, 0x17, 0x40, 0x72, 0xeb, 0xb2, 0x97, 0x31, 0x66,
+    0x18, 0x48, 0x9a, 0xe5, 0x3a, 0x2a, 0x41, 0x13, 0x3e, 0xfc, 0xfb, 0xb4,
+    0xb0, 0x96, 0x6e, 0x53, 0x37, 0x18, 0xbb, 0x26, 0x1d, 0xbe, 0x33, 0x0f,
+    0x06, 0x8b, 0x8c, 0xb1, 0xfc, 0x8c, 0x24, 0x19, 0x8d, 0x7d, 0x76, 0x52,
+    0x35, 0x75, 0x71, 0x36, 0x61, 0x7d, 0x75, 0x3a, 0x31, 0x9a, 0x16, 0x05,
+    0x2d, 0x51, 0x63, 0x6f, 0x07, 0x64, 0xfd, 0x80, 0x16, 0x2d, 0xa3, 0x3a,
+    0x15, 0xca, 0xaa, 0x76, 0xec, 0x2f, 0x91, 0x47, 0xb2, 0x29, 0x61, 0x04,
+    0x80, 0x20, 0x8d, 0x3c, 0x31, 0xa6, 0x4f, 0x8b, 0xc8, 0xc0, 0x71, 0xbb,
+    0x0a, 0xec, 0xbc, 0xdf, 0xdc, 0x91, 0x8c, 0xb9, 0x80, 0xb7, 0x67, 0xa9,
+    0x7f, 0x30, 0x18, 0x4e, 0xd3, 0x68, 0x27, 0x50, 0x15, 0xad, 0x8c, 0x6a,
+    0xab, 0xc9, 0xbe, 0xad, 0x41, 0x4b, 0xcd, 0x23, 0x73, 0x9f, 0x77, 0x58,
+    0xe3, 0xd8, 0x2e, 0x16, 0xcb, 0xa0, 0x17, 0x89, 0x51, 0x31, 0x53, 0x01,
+    0xa8, 0xf1, 0x9b, 0x61, 0xc3, 0x0a, 0x5b, 0x0c, 0x70, 0x36, 0x48, 0x1b,
+    0xae, 0x17, 0x51, 0x1f, 0xc7, 0x7b, 0xce, 0xd4, 0x45, 0xff, 0xea, 0xb0,
+    0x5f, 0x48, 0x07, 0x4f, 0x79, 0x26, 0x5c, 0xb6, 0xce, 0x4c, 0xc4, 0x02,
+    0xd1, 0x31, 0x88, 0xa9, 0xc0, 0x53, 0x6a, 0x42, 0x6f, 0x9c, 0x32, 0xaa,
+    0x86, 0xec, 0x25, 0xa7, 0x5b, 0x31, 0x68, 0xc9, 0xa9, 0xd8, 0x2c, 0x70,
+    0xa0, 0x02, 0x31, 0x52, 0x8a, 0x2c, 0xc0, 0x0a, 0xbe, 0x8c, 0x59, 0x6c,
+    0x72, 0x42, 0x21, 0xcb, 0x44, 0x07, 0x02, 0x27, 0xa0, 0x71, 0xa3, 0x7f,
+    0xe3, 0x97, 0x24, 0x70, 0x47, 0x4d, 0x10, 0xfc, 0x54, 0x83, 0xdc, 0x44,
+    0x09, 0x36, 0x23, 0x4a, 0x26, 0x95, 0x60, 0x96, 0xa4, 0x11, 0x1b, 0x18,
+    0x9d, 0x01, 0x9c, 0x8c, 0xd7, 0x37, 0x60, 0x08, 0x02, 0xef, 0xe3, 0x81,
+    0xf3, 0x48, 0x5c, 0x9c, 0xac, 0x4f, 0xb6, 0xc7, 0x66, 0xd6, 0xda, 0x25,
+    0x78, 0x4a, 0xca, 0x91, 0xf1, 0x16, 0x75, 0x69, 0x8b, 0x09, 0x63, 0x0d,
+    0x74, 0x49, 0x57, 0x33, 0xe1, 0x23, 0x87, 0xc5, 0x0e, 0x85, 0x27, 0x1e,
+    0x5a, 0xfa, 0x3f, 0xa8, 0x82, 0xbc, 0x49, 0xc7, 0x99, 0x15, 0xe1, 0x2f,
+    0x04, 0x36, 0x88, 0xd4, 0xa1, 0x9a, 0xe5, 0xb3, 0x70, 0x95, 0x85, 0x43,
+    0x76, 0xb9, 0x7d, 0x3b, 0x9c, 0x61, 0xf3, 0x30, 0x59, 0x4e, 0x2a, 0xc6,
+    0x3f, 0x52, 0x35, 0x81, 0x43, 0x61, 0x72, 0xc0, 0x89, 0x98, 0x67, 0x1e,
+    0x6f, 0xec, 0xc6, 0x2a, 0x9a, 0x14, 0x36, 0x34, 0x4c, 0x9f, 0xfb, 0x2e,
+    0xd1, 0xd2, 0x4e, 0x6b, 0xb9, 0xc9, 0x56, 0x74, 0xbe, 0xab, 0xa4, 0x7c,
+    0x48, 0x84, 0x07, 0xf6, 0x04, 0xb1, 0x89, 0x0b, 0x13, 0x79, 0x13, 0xb5,
+    0x31, 0xd6, 0x2c, 0x40, 0x47, 0xbd, 0xba, 0x37, 0xb1, 0x65, 0x7c, 0xb3,
+    0xa3, 0x45, 0x1e, 0x0f, 0x41, 0x62, 0x07, 0xf9, 0x1e, 0x25, 0xa5, 0x78,
+    0x47, 0xd2, 0xa6, 0x4b, 0x20, 0x7b, 0x9b, 0x39, 0x07, 0x09, 0xf3, 0x9e,
+    0x09, 0xfb, 0xac, 0x87, 0xb6, 0xb5, 0x9b, 0xd8, 0x09, 0xa3, 0xd6, 0x69,
+    0xb3, 0x3a, 0x87, 0x09, 0xb0, 0x19, 0xb3, 0xc1, 0x47, 0x8e, 0xd7, 0x3a,
+    0x6e, 0xb5, 0x48, 0x89, 0x56, 0x87, 0x60, 0xb1, 0xba, 0x52, 0xd5, 0x94,
+    0x22, 0x54, 0xbd, 0x7c, 0xf1, 0xa4, 0x54, 0xaa, 0x38, 0x5c, 0x76, 0xa8,
+    0x52, 0x19, 0x97, 0x9a, 0x71, 0x47, 0x6c, 0xa0, 0x39, 0xd1, 0x0b, 0xd0,
+    0xa6, 0xb3, 0x65, 0xdc, 0xbc, 0xa4, 0x4d, 0x62, 0x44, 0xb2, 0x47, 0x5e,
+    0x77, 0x77, 0x32, 0x2f, 0x78, 0xa6, 0x97, 0xdb, 0xb5, 0xba, 0x3b, 0x4a,
+    0xcb, 0x0b, 0x33, 0xa2, 0xac, 0xc4, 0x94, 0x56, 0x1a, 0x36, 0x1c, 0x0d,
+    0xa3, 0x57, 0x5b, 0x63, 0x6c, 0x0d, 0x1f, 0xe1, 0xa8, 0x36, 0xd5, 0x5d,
+    0x38, 0x5c, 0xac, 0xf4, 0x67, 0x39, 0x9a, 0x12, 0x5b, 0xef, 0xa1, 0x0a,
+    0x57, 0x76, 0x87, 0x83, 0xaa, 0xaf, 0x1d, 0x9c, 0xce, 0x2b, 0x78, 0x9b,
+    0x40, 0x82, 0x1e, 0x34, 0xb3, 0x55, 0x2d, 0xd0, 0x20, 0xcd, 0x5b, 0x46,
+    0x8d, 0xda, 0xb8, 0x83, 0xa8, 0xab, 0xfb, 0x36, 0x45, 0xcb, 0x40, 0xae,
+    0x69, 0x77, 0x03, 0x22, 0xa8, 0xb4, 0xaa, 0x17, 0x53, 0x90, 0x05, 0x6a,
+    0x69, 0xb9, 0xc5, 0x2d, 0xbc, 0x9a, 0x81, 0xf6, 0x2a, 0x3c, 0x57, 0x96,
+    0x8c, 0xb2, 0x72, 0xa7, 0xd4, 0x84, 0x77, 0xf9, 0x0b, 0x80, 0xe7, 0x1e,
+    0x75, 0x61, 0x0e, 0xf9, 0xb0, 0xcf, 0x4c, 0x03, 0xca, 0x30, 0x45, 0x50,
+    0x25, 0x82, 0x56, 0x02, 0xbb, 0x58, 0xab, 0x99, 0xc7, 0x8d, 0xd5, 0x37,
+    0x12, 0xc8, 0x36, 0x5b, 0x00, 0x5f, 0x91, 0xf6, 0x2d, 0x9b, 0x91, 0xc2,
+    0x3e, 0x75, 0x56, 0x83, 0xd2, 0xaa, 0xd4, 0x03, 0xcd, 0xe8, 0xe8, 0x3f,
+    0x09, 0xc1, 0x8e, 0x84, 0xb1, 0x75, 0x85, 0x06, 0xa7, 0x4a, 0x40, 0xc2,
+    0xc9, 0x90, 0xb0, 0x0f, 0x59, 0x84, 0xe5, 0xf7, 0xa8, 0xd8, 0x35, 0x33,
+    0xa5, 0x82, 0x4e, 0xf6, 0xb5, 0xaf, 0xd5, 0xaa, 0xbb, 0x52, 0x30, 0x0b,
+    0xb1, 0x67, 0x7b, 0xbb, 0xdc, 0x38, 0x58, 0xf4, 0x2f, 0xe4, 0xeb, 0x47,
+    0xf0, 0x49, 0x76, 0x45, 0x10, 0x02, 0x19, 0xa7, 0xc6, 0x1f, 0x8a, 0x71,
+    0xda, 0x51, 0x61, 0x79, 0xc4, 0x10, 0xeb, 0x3a, 0x11, 0xd9, 0x93, 0x1d,
+    0x83, 0x81, 0x48, 0x3d, 0x68, 0x35, 0xff, 0xe3, 0xa6, 0xa8, 0x40, 0x74,
+    0xdb, 0x7c, 0xb4, 0xb2, 0x05, 0x89, 0xc8, 0x09, 0x42, 0x27, 0x28, 0x55,
+    0x01, 0x57, 0xc9, 0xf9, 0xfa, 0x36, 0xd3, 0x5c, 0x51, 0x40, 0xca, 0x1e,
+    0x34, 0xc8, 0xb9, 0x27, 0xf1, 0x15, 0xc9, 0xa4, 0x18, 0x9c, 0xa8, 0x4c,
+    0x55, 0xf8, 0x4d, 0x90, 0xbc, 0x88, 0xd1, 0x46, 0x01, 0x80, 0x96, 0x54,
+    0x8d, 0x01, 0x6e, 0xe4, 0x26, 0x0c, 0x7a, 0x08, 0x3d, 0x7c, 0x26, 0x66,
+    0xb1, 0xd1, 0x15, 0xc7, 0xc0, 0x0b, 0x06, 0x92, 0x9c, 0x26, 0xa6, 0x6c,
+    0x3a, 0x46, 0x47, 0x15, 0x37, 0xb0, 0x0a, 0xc1, 0x5d, 0xe0, 0x51, 0xae,
+    0x17, 0x87, 0x2f, 0x75, 0x2c, 0x64, 0xd5, 0x39, 0x09, 0xe6, 0xd0, 0x7c,
+    0x3d, 0x79, 0x47, 0x78, 0x0a, 0x82, 0xc9, 0xba, 0x37, 0x07, 0x93, 0x94,
+    0xa4, 0x45, 0x7c, 0x07, 0x69, 0x24, 0x1d, 0xc9, 0x75, 0x41, 0x6b, 0xc1,
+    0x42, 0x28, 0x06, 0xe3, 0xfc, 0x7b, 0xd2, 0xf8, 0xbf, 0xe7, 0x5a, 0xc2,
+    0xc0, 0x81, 0x63, 0xf3, 0x84, 0x32, 0x31, 0x4a, 0x8d, 0x6b, 0xe3, 0x3e,
+    0x22, 0x67, 0x9a, 0x3a, 0x96, 0x09, 0xa6, 0xf9, 0x53, 0x40, 0x41, 0x2a,
+    0x04, 0xa7, 0xc5, 0x7b, 0x86, 0xcd, 0xed, 0xec, 0xae, 0xfd, 0xc7, 0x11,
+    0x48, 0x56, 0x77, 0x0b, 0xb7, 0xbb, 0xaf, 0xfb, 0x6c, 0x9e, 0xd6, 0x5c,
+    0xbc, 0xf7, 0x9a, 0x75, 0xb5, 0xb2, 0x20, 0xd9, 0x60, 0x90, 0x65, 0x02,
+    0xf9, 0x16, 0x34, 0xdf, 0x0b, 0x16, 0x2a, 0x97, 0x00, 0x5d, 0xc1, 0x65,
+    0xc3, 0xb9, 0x1f, 0x2e, 0x85, 0x97, 0xbd, 0xca, 0xaa, 0x1d, 0xf2, 0x4f,
+    0x74, 0xe5, 0x56, 0x94, 0xdc, 0x53, 0xbb, 0xc0, 0x75, 0x1c, 0x2b, 0x59,
+    0x6b, 0x50, 0x2c, 0x25, 0x4c, 0x78, 0xd7, 0x68, 0x40, 0x0b, 0x91, 0x7a,
+    0x93, 0x02, 0x83, 0x5e, 0x6c, 0x03, 0xc7, 0xc4, 0x24, 0x6f, 0x8b, 0xa4,
+    0x70, 0x37, 0x1f, 0xe5, 0x33, 0x59, 0xf6, 0xbb, 0x5f, 0xb8, 0x58, 0x50,
+    0x62, 0x16, 0x95, 0x2a, 0x88, 0xa3, 0xc6, 0x24, 0x94, 0x4b, 0xb0, 0x03,
+    0x8e, 0xe6, 0x50, 0xd1, 0x63, 0xa2, 0xab, 0x00, 0x16, 0xf4, 0x0a, 0x7d,
+    0xe6, 0xe0, 0xb9, 0x0c, 0xd8, 0x08, 0xae, 0xf6, 0x80, 0xb7, 0x48, 0xb8,
+    0x10, 0xd1, 0x77, 0x57, 0x48, 0x2a, 0xc1, 0xf1, 0x4e, 0x61, 0xb4, 0x06,
+    0x5a, 0xa1, 0xba, 0x32, 0x4a, 0x9a, 0xab, 0x8c, 0xa8, 0xe3, 0xa0, 0x68,
+    0x39, 0xa3, 0x25, 0x55, 0x48, 0xcd, 0x12, 0x98, 0x14, 0x1b, 0x39, 0x5b,
+    0xf4, 0x88, 0xbe, 0x5f, 0xac, 0xba, 0x18, 0x20, 0x74, 0x2c, 0xa1, 0x0b,
+    0xfc, 0xf1, 0x00, 0x85, 0x24, 0x27, 0x3d, 0x80, 0xb6, 0x30, 0x42, 0x7b,
+    0x74, 0xb0, 0xbf, 0x87, 0x51, 0x9b, 0xa8, 0x1c, 0x79, 0xbd, 0x50, 0x85,
+    0x66, 0xe1, 0x93, 0xdd, 0xc5, 0x5d, 0x5d, 0xd0, 0xbe, 0xcb, 0x90, 0x36,
+    0xf8, 0xc6, 0xc2, 0xea, 0xea, 0x40, 0xce, 0xa7, 0xb0, 0xae, 0xc5, 0x44,
+    0x3a, 0x27, 0xc5, 0x4a, 0xf0, 0x21, 0x4f, 0xf6, 0x63, 0xb1, 0x8c, 0x20,
+    0x76, 0x65, 0xb5, 0x79, 0x55, 0x10, 0xa5, 0xa7, 0x4b, 0x57, 0x96, 0xb3,
+    0x03, 0xe6, 0xa8, 0x93, 0xf5, 0xc5, 0xca, 0xe0, 0x1a, 0x23, 0x30, 0x6d,
+    0x09, 0x07, 0x81, 0x5e, 0x05, 0xc6, 0x1b, 0x7a, 0x0e, 0xde, 0xf3, 0x00,
+    0x91, 0xf3, 0xbb, 0x4b, 0xa6, 0x8e, 0x96, 0xc3, 0x3a, 0xc8, 0x72, 0x19,
+    0x23, 0x23, 0xc7, 0x94, 0x46, 0x75, 0xa2, 0xc5, 0x9e, 0xa3, 0x15, 0x86,
+    0xb4, 0xa7, 0x95, 0xda, 0x16, 0xae, 0x42, 0xe8, 0xcc, 0xf6, 0x41, 0xbc,
+    0x9c, 0xe8, 0x07, 0xc9, 0x05, 0x3c, 0x74, 0xb2, 0xad, 0x77, 0xc4, 0x08,
+    0x56, 0x78, 0xb8, 0x65, 0x2a, 0x33, 0x39, 0x82, 0x16, 0x3c, 0x2b, 0x73,
+    0x41, 0x2a, 0xbc, 0xc8, 0x36, 0x23, 0x2c, 0x23, 0x29, 0xce, 0x94, 0x8a,
+    0xba, 0x13, 0x3f, 0xfa, 0xcc, 0x6e, 0x17, 0x40, 0xb0, 0xb4, 0x9c, 0xae,
+    0xf9, 0x72, 0x40, 0xf7, 0x2a, 0xaf, 0x00, 0x17, 0x7e, 0x88, 0x44, 0x4e,
+    0x32, 0xa4, 0x80, 0x96, 0x53, 0x20, 0xe4, 0xaa, 0x18, 0x9c, 0x69, 0x63,
+    0xdb, 0x81, 0x73, 0x0e, 0x64, 0x40, 0x12, 0xc1, 0x26, 0x0e, 0xac, 0x4d,
+    0x38, 0xa6, 0x4c, 0x05, 0xeb, 0x42, 0x1f, 0x88, 0x6e, 0x6c, 0xa3, 0x98,
+    0x95, 0xc3, 0x5a, 0x31, 0xfc, 0x8a, 0x7c, 0xd6, 0xa5, 0x6c, 0x5a, 0xc9,
+    0xf5, 0xf2, 0xb0, 0xf7, 0x05, 0x8d, 0x3a, 0x0b, 0x3f, 0x4d, 0x1b, 0x0e,
+    0x38, 0x7b, 0x1c, 0xe5, 0xd0, 0x75, 0x40, 0x77, 0xc2, 0xe0, 0x8b, 0xa9,
+    0xfb, 0xa6, 0xa7, 0x13, 0xf0, 0xbc, 0x0c, 0x13, 0xb0, 0x70, 0x3a, 0x2f,
+    0x20, 0xe7, 0x38, 0xd8, 0x82, 0xa4, 0xc0, 0x06, 0x96, 0x95, 0x75, 0x5c,
+    0xbc, 0x68, 0xce, 0xee, 0xa6, 0x44, 0xbb, 0xf2, 0x62, 0x14, 0x43, 0x10,
+    0xe6, 0x0b, 0x5c, 0x66, 0x02, 0xbf, 0x38, 0xe9, 0x8f, 0x19, 0x69, 0x6c,
+    0x08, 0xfa, 0x93, 0x23, 0xf1, 0x35, 0x5f, 0x33, 0xcf, 0xe2, 0x32, 0x11,
+    0xda, 0x31, 0xbb, 0xd8, 0xf5, 0x7e, 0x55, 0xc3, 0x6a, 0xa3, 0x04, 0x8c,
+    0xef, 0x50, 0x67, 0x0f, 0xe9, 0xbb, 0x11, 0x6b, 0xca, 0x5a, 0x23, 0x15,
+    0xf7, 0x52, 0x8c, 0x69, 0xbb, 0x2d, 0x26, 0xd3, 0x78, 0x32, 0x33, 0x9b,
+    0x1d, 0x02, 0x7c, 0x22, 0x4b, 0x57, 0x19, 0xec, 0xcd, 0x16, 0x63, 0x5d,
+    0x1f, 0x0c, 0x67, 0xda, 0x6a, 0xc7, 0x2c, 0xf1, 0x0b, 0xcf, 0x92, 0x10,
+    0xcb, 0x78, 0x57, 0x67, 0x61, 0x0e, 0xb3, 0x55, 0xb0, 0x17, 0x32, 0x4e,
+    0x95, 0xf1, 0xcb, 0xb5, 0xdb, 0x5d, 0x8e, 0x38, 0x97, 0x28, 0x46, 0x1e,
+    0x37, 0x4b, 0x5c, 0x03, 0xf4, 0x84, 0x0c, 0xfc, 0x49, 0x3b, 0xd2, 0xc6,
+    0x97, 0xd4, 0x4f, 0xef, 0xe6, 0x5c, 0xb2, 0x96, 0x8e, 0xbc, 0x18, 0x9f,
+    0xec, 0x8a, 0x67, 0x53, 0xe8, 0x2a, 0x41, 0x5c, 0x6e, 0xfe, 0xca, 0x1a,
+    0xd0, 0x03, 0x4f, 0xe8, 0xd9, 0xb0, 0xe2, 0xa1, 0x6c, 0x32, 0xd5, 0x37,
+    0x68, 0x9c, 0x6b, 0x30, 0x87, 0xb4, 0x6e, 0xa8, 0xc5, 0x45, 0xe4, 0x74,
+    0x4a, 0x80, 0x02, 0x84, 0x78, 0x0e, 0x2c, 0x9c, 0x37, 0x07, 0x26, 0x31,
+    0x88, 0x0a, 0x89, 0xd2, 0xba, 0x8b, 0x09, 0xb2, 0x16, 0x7b, 0x23, 0xa8,
+    0x0c, 0x82, 0xc4, 0x22, 0xa2, 0x21, 0x2d, 0xa4, 0xa0, 0xeb, 0xe4, 0xa6,
+    0xd4, 0x16, 0xa0, 0xa7, 0x19, 0x8b, 0x8f, 0x87, 0x9b, 0x53, 0x6c, 0xba,
+    0x14, 0xa7, 0xc4, 0x64, 0x08, 0xb4, 0x68, 0xda, 0x85, 0xa6, 0x47, 0xbc,
+    0x58, 0x34, 0xcd, 0x60, 0x43, 0xad, 0x14, 0xd4, 0xca, 0xd7, 0xb1, 0x6c,
+    0xc0, 0x05, 0x68, 0xaf, 0xa7, 0x08, 0x9d, 0x6a, 0xb0, 0x70, 0x96, 0x81,
+    0xb8, 0x55, 0xbf, 0xa1, 0xcc, 0xb1, 0x37, 0xe0, 0x94, 0x42, 0x05, 0x0c,
+    0x83, 0xef, 0x6d, 0xf0, 0x4e, 0xba, 0xe6, 0x78, 0x49, 0xaf, 0x1f, 0x88,
+    0xf0, 0x18, 0x0c, 0x17, 0x66, 0x92, 0xd8, 0x50, 0x57, 0x3b, 0x8e, 0xc9,
+    0xd5, 0x8c, 0xfb, 0x9b, 0x78, 0x65, 0x01, 0x76, 0x7a, 0x0e, 0xf0, 0x7f,
+    0x2b, 0xc4, 0x48, 0x81, 0xc2, 0xb7, 0xc1, 0x6e, 0x4b, 0xc7, 0x33, 0xa3,
+    0x9b, 0xf1, 0xcf, 0x63, 0x77, 0x52, 0x07, 0xe1, 0x9f, 0xa9, 0x6b, 0xce,
+    0x02, 0xbf, 0x06, 0x8d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+const uint8_t kExpectedCiphertext[BCM_MLKEM768_CIPHERTEXT_BYTES] = {
+    0x8c, 0xfa, 0xd2, 0x09, 0x06, 0x1b, 0xff, 0x23, 0x9f, 0x84, 0x61, 0xfd,
+    0x69, 0x7a, 0xa6, 0x2c, 0x57, 0x43, 0x64, 0x6b, 0x6b, 0x6b, 0xa3, 0xe1,
+    0xa9, 0x4f, 0x3e, 0x29, 0xff, 0x3d, 0xb1, 0x84, 0x51, 0x1d, 0x48, 0xe3,
+    0xf2, 0xf9, 0x5c, 0x9b, 0xf8, 0x05, 0xa1, 0x4c, 0xf4, 0x78, 0xce, 0xd8,
+    0xc8, 0x0a, 0xc9, 0x71, 0xa7, 0x50, 0x89, 0xde, 0x66, 0x11, 0x68, 0x2c,
+    0x70, 0x0f, 0xa3, 0x15, 0xa7, 0x8f, 0xa7, 0xd1, 0x49, 0x32, 0x2b, 0xe7,
+    0xe3, 0x63, 0xff, 0x6b, 0x8c, 0x77, 0xd8, 0x97, 0x6f, 0x6c, 0x80, 0xc2,
+    0x73, 0x7d, 0xe2, 0x39, 0x6f, 0x61, 0x4f, 0xa3, 0x85, 0x14, 0x8e, 0x68,
+    0x58, 0x18, 0xba, 0x1c, 0x19, 0x01, 0x4c, 0x06, 0x73, 0x58, 0x4a, 0x9d,
+    0xdd, 0x2e, 0x78, 0x82, 0x62, 0xbf, 0x15, 0x0c, 0x8e, 0xa7, 0xcf, 0xee,
+    0xd7, 0x9a, 0x42, 0x30, 0xf5, 0x44, 0xdc, 0x3f, 0xdc, 0x67, 0x5c, 0x06,
+    0xf0, 0xcf, 0x3b, 0x24, 0x9e, 0xfa, 0xe8, 0x4b, 0x3b, 0x00, 0x01, 0x7c,
+    0x4d, 0x50, 0xa8, 0xac, 0x30, 0x74, 0xf4, 0x73, 0x98, 0x5e, 0x09, 0x92,
+    0xbd, 0xe1, 0xc4, 0x3a, 0x9f, 0xd0, 0x62, 0xc8, 0x4e, 0x7f, 0xb0, 0xaa,
+    0xb3, 0x8c, 0xb5, 0xf9, 0x57, 0xe3, 0x90, 0x9a, 0x94, 0x0d, 0xdb, 0x9e,
+    0xf7, 0x78, 0xbf, 0x18, 0xd0, 0x02, 0x8e, 0x02, 0x04, 0xbe, 0xee, 0x87,
+    0x49, 0xb1, 0xfe, 0x28, 0xd2, 0xdb, 0xd0, 0x7a, 0x12, 0x50, 0xa3, 0xc6,
+    0x32, 0xd6, 0x06, 0xa6, 0xc5, 0xb0, 0xa8, 0xbe, 0x49, 0x8a, 0x8b, 0xfe,
+    0xf6, 0xb1, 0xe5, 0xb6, 0xf0, 0x61, 0xc6, 0x1f, 0xe7, 0xcb, 0x4d, 0x66,
+    0xdd, 0xe4, 0xd2, 0x2b, 0x73, 0xbd, 0x03, 0x79, 0x76, 0x05, 0x87, 0x58,
+    0x6f, 0x6f, 0x8f, 0x20, 0x4f, 0x1f, 0x81, 0xa9, 0x9c, 0x22, 0x8d, 0xbd,
+    0xef, 0x41, 0x5e, 0x39, 0x9e, 0x90, 0x4b, 0x63, 0x8b, 0x50, 0xac, 0x4f,
+    0x20, 0x08, 0x82, 0x53, 0x52, 0x86, 0xce, 0x55, 0xf5, 0x21, 0xd7, 0x8c,
+    0xdf, 0xf3, 0x54, 0x90, 0xed, 0x27, 0xa9, 0x95, 0xbb, 0xec, 0x7a, 0xe2,
+    0xeb, 0x80, 0x29, 0xca, 0xc9, 0x4b, 0x1a, 0xfe, 0xe8, 0x40, 0xcf, 0x70,
+    0x37, 0xb3, 0xb8, 0xb3, 0x04, 0xf6, 0xc3, 0x44, 0x1e, 0xf8, 0x40, 0x95,
+    0xf9, 0x92, 0x97, 0x63, 0xab, 0x35, 0x11, 0x7b, 0x2d, 0x9e, 0x5b, 0xeb,
+    0xfe, 0x80, 0xfe, 0xc3, 0xc6, 0xa4, 0x8c, 0xac, 0xd2, 0xa5, 0x0d, 0x11,
+    0xcd, 0xbc, 0xdd, 0x57, 0x9d, 0xf4, 0xbc, 0xdf, 0xbe, 0xa2, 0xfc, 0xcd,
+    0x2b, 0x83, 0x0e, 0x4e, 0x77, 0x44, 0x10, 0x93, 0xeb, 0xca, 0xec, 0xb6,
+    0x26, 0x48, 0x45, 0x08, 0x72, 0xd4, 0xfe, 0xa2, 0xe5, 0xc8, 0x12, 0x8f,
+    0x38, 0xcd, 0xd6, 0xaa, 0x97, 0xd4, 0xad, 0xb3, 0x0b, 0x19, 0x5b, 0x70,
+    0x50, 0xbf, 0x9d, 0x45, 0xd6, 0x0d, 0xf6, 0x72, 0x08, 0x0f, 0x98, 0xbd,
+    0x1f, 0x39, 0xea, 0x4c, 0x76, 0xa8, 0x6e, 0xc2, 0x24, 0xe3, 0x3d, 0xf4,
+    0x40, 0xe8, 0x68, 0xfe, 0xaf, 0xeb, 0xae, 0x65, 0x84, 0x86, 0x10, 0xb6,
+    0x58, 0x75, 0xb9, 0x22, 0x6d, 0x74, 0x5d, 0xa7, 0xc0, 0x17, 0x10, 0x0f,
+    0x36, 0x5f, 0x99, 0xf3, 0x60, 0x39, 0xeb, 0x6e, 0x04, 0x4d, 0x29, 0xc7,
+    0xec, 0x2a, 0x1d, 0x8f, 0x5c, 0x23, 0x84, 0xba, 0x65, 0xe9, 0xab, 0x32,
+    0xd4, 0x62, 0xd1, 0x53, 0xb8, 0x71, 0x40, 0x9a, 0xf0, 0x05, 0xdb, 0xa0,
+    0x5a, 0xca, 0xeb, 0xb0, 0xbf, 0xfe, 0x7e, 0x19, 0x32, 0x42, 0xef, 0xab,
+    0xf3, 0x49, 0x13, 0x50, 0x08, 0x98, 0xcd, 0xcf, 0x5a, 0x77, 0x5d, 0xe6,
+    0x3f, 0x9d, 0xa0, 0x21, 0x98, 0xcb, 0x78, 0x69, 0xd8, 0x22, 0xdb, 0xae,
+    0x87, 0x2c, 0x38, 0x0a, 0x96, 0xa2, 0x30, 0x8f, 0x37, 0xe4, 0xc5, 0x94,
+    0x57, 0x40, 0x30, 0xa0, 0x4e, 0x7c, 0xfe, 0x6f, 0x2e, 0x15, 0x88, 0x7b,
+    0xf2, 0x22, 0x9c, 0x95, 0x7e, 0xd6, 0x2d, 0x37, 0xd4, 0x13, 0x95, 0x31,
+    0xf6, 0xbb, 0xf4, 0xaf, 0x33, 0x42, 0xf0, 0x45, 0xb1, 0xa8, 0xb4, 0x09,
+    0x9a, 0x6d, 0x7a, 0xdb, 0xb0, 0xf2, 0x00, 0xdc, 0x77, 0x6a, 0x43, 0xf1,
+    0xbb, 0x56, 0xc5, 0x7c, 0xee, 0xa6, 0xd6, 0x10, 0xa0, 0x81, 0xca, 0x28,
+    0xab, 0x48, 0xb4, 0x72, 0xbc, 0xe6, 0xe2, 0x24, 0xef, 0x49, 0xdc, 0xb5,
+    0x1f, 0x83, 0xe7, 0xda, 0xdd, 0x73, 0x5c, 0x7b, 0x85, 0x4a, 0x15, 0x7b,
+    0xcb, 0xf1, 0x14, 0x6b, 0x32, 0xef, 0xce, 0xaf, 0x37, 0x04, 0xa4, 0x1e,
+    0xcb, 0x1b, 0x84, 0x1d, 0xdb, 0xbf, 0x2f, 0x88, 0x89, 0xf4, 0x5e, 0xb0,
+    0x32, 0x99, 0x81, 0x9c, 0x8a, 0xb0, 0xfd, 0x28, 0x6f, 0xc9, 0xe9, 0xaf,
+    0x60, 0x11, 0xa5, 0x8d, 0xa4, 0xfb, 0x93, 0x91, 0x7a, 0xa0, 0xd2, 0xcd,
+    0xda, 0x4d, 0xf3, 0xfe, 0xc8, 0x55, 0x4f, 0x26, 0x9d, 0x56, 0x87, 0x12,
+    0xfe, 0x93, 0x3e, 0x34, 0xf5, 0x3d, 0x4f, 0x6e, 0x26, 0x56, 0xf7, 0x80,
+    0xa2, 0xb9, 0x0f, 0xa1, 0xf8, 0x72, 0xb0, 0xaa, 0xec, 0xe2, 0x97, 0xd0,
+    0x3a, 0x6d, 0xe5, 0xe9, 0x12, 0x1b, 0x32, 0x0a, 0xdb, 0x52, 0x8f, 0x9d,
+    0xd0, 0xff, 0x67, 0xcc, 0x63, 0x41, 0x32, 0x2f, 0xe7, 0x0c, 0xb0, 0xa5,
+    0x73, 0xc5, 0xc3, 0x54, 0x75, 0x06, 0x8e, 0x36, 0x54, 0xea, 0x9c, 0x6b,
+    0x60, 0xee, 0x10, 0x06, 0xd2, 0xb3, 0x8c, 0xe3, 0x09, 0xfe, 0x1e, 0x47,
+    0xc3, 0xd5, 0x6c, 0x0d, 0x0c, 0x84, 0x5e, 0x4f, 0x01, 0xfa, 0xcf, 0xae,
+    0xc1, 0xac, 0xd9, 0xb0, 0x03, 0x74, 0x8e, 0xc5, 0x57, 0x51, 0x96, 0x23,
+    0x72, 0xc6, 0x81, 0x7f, 0xf1, 0x6c, 0x29, 0xea, 0x31, 0x2a, 0x23, 0xbb,
+    0x88, 0x6f, 0x01, 0xa2, 0x2f, 0x69, 0xd2, 0x1c, 0xe8, 0x1e, 0x63, 0x44,
+    0xd9, 0x90, 0x0b, 0x57, 0x78, 0xc6, 0xd1, 0xb3, 0xf6, 0x97, 0x99, 0xd8,
+    0x09, 0xe0, 0x9d, 0x69, 0x00, 0xa0, 0xd4, 0xe0, 0x80, 0xfd, 0xdf, 0x23,
+    0x3a, 0xf8, 0xc0, 0x97, 0xea, 0xb6, 0xbf, 0x87, 0x75, 0x40, 0x1e, 0x0d,
+    0x1e, 0x6c, 0x84, 0xa4, 0x7e, 0xbb, 0xa3, 0x02, 0x76, 0x76, 0xc8, 0x4e,
+    0x8b, 0x21, 0x3d, 0x27, 0xbc, 0x38, 0x0f, 0x79, 0xfb, 0xc5, 0xdd, 0x37,
+    0x67, 0xcb, 0x61, 0x5a, 0x12, 0x85, 0x31, 0x91, 0x3e, 0x7a, 0x4b, 0x6c,
+    0xfd, 0x4e, 0x54, 0x47, 0xfc, 0xc5, 0x2e, 0x34, 0xe4, 0xaa, 0x3d, 0xa2,
+    0xd3, 0x1d, 0x15, 0xbc, 0xea, 0xa7, 0xe3, 0xcd, 0xd6, 0x49, 0xee, 0x06,
+    0x11, 0x2b, 0xf1, 0x58, 0x81, 0xdd, 0x99, 0xe1, 0xbd, 0x63, 0xa0, 0xd7,
+    0xa0, 0x4b, 0x01, 0xab, 0xf3, 0x5c, 0x35, 0xf0, 0xb0, 0xdc, 0xd0, 0x87,
+    0x78, 0x02, 0xec, 0x99, 0x0e, 0xb2, 0x23, 0x8b, 0xb1, 0x44, 0x93, 0x65,
+    0xd5, 0x1c, 0x00, 0x7e, 0x98, 0xb3, 0x5e, 0xf9, 0xca, 0xbc, 0x26, 0x38,
+    0x18, 0x22, 0x14, 0x3c, 0xed, 0x8d, 0x54, 0xa4, 0x05, 0x00, 0x7f, 0xfb,
+    0xd5, 0x73, 0x77, 0xf4, 0x98, 0xa0, 0xf7, 0x60, 0xb4, 0x47, 0x10, 0x75,
+    0x30, 0x2d, 0xde, 0x9c, 0x3e, 0x08, 0x8f, 0xe5, 0xc9, 0x5a, 0xd9, 0x20,
+    0xf3, 0x97, 0xb5, 0xd1, 0xb3, 0x90, 0x23, 0x6f, 0x9f, 0x5e, 0xf1, 0x0f,
+    0x76, 0x18, 0xbf, 0x2b, 0x23, 0x8e, 0x45, 0x3f, 0xaf, 0x2b, 0x53, 0x78,
+    0x27, 0xa2, 0xf6, 0x07, 0x2b, 0x61, 0x24, 0x5b, 0xc7, 0x2e, 0x25, 0xf1,
+    0xb3, 0x4c, 0x50, 0xe8, 0x6d, 0xee, 0x56, 0x52, 0x37, 0xd0, 0x6e, 0xd6,
+    0xcb, 0xc8, 0x2a, 0xb1, 0xba, 0x49, 0xc7, 0x5a, 0x55, 0x3c, 0x6f, 0x16,
+    0x64, 0x08, 0xa6, 0x46, 0x09, 0x37, 0x86, 0x0b, 0xe7, 0x7e, 0x2d, 0xf4,
+    0x96, 0x80, 0x41, 0x77, 0x1a, 0xf9, 0xd2, 0xe0, 0xf3, 0x64, 0x0e, 0x3f,
+    0x3d, 0xe1, 0xec, 0x63, 0x40, 0x10, 0x15, 0xcf, 0x4c, 0xc9, 0x1c, 0x9b,
+    0x9f, 0xe8, 0x50, 0x27, 0xc2, 0x54, 0x44, 0x14, 0xb6, 0x2e, 0xe4, 0x53,
+    0xf2, 0x60, 0x8a, 0xb6, 0x1c, 0x14, 0xb6, 0x25, 0xf2, 0x44, 0x59, 0xb7,
+    0x67, 0x3b, 0x94, 0x88, 0x15, 0x70, 0x6f, 0xa8};
+
+const uint8_t kExpectedSharedSecret[BCM_MLKEM_SHARED_SECRET_BYTES] = {
+    0x7d, 0x9f, 0x1c, 0xb4, 0xae, 0x04, 0xd7, 0x5f, 0xa6, 0x57, 0x5a,
+    0xe0, 0xe4, 0x29, 0xb5, 0x73, 0xa9, 0x74, 0xb7, 0xa1, 0x25, 0xbd,
+    0xfb, 0x8a, 0x6e, 0x0f, 0x19, 0xba, 0xe1, 0x16, 0xae, 0x81};
+
+const uint8_t
+    kExpectedImplicitRejectionSharedSecret[BCM_MLKEM_SHARED_SECRET_BYTES] = {
+        0xa3, 0x19, 0x2a, 0x8c, 0x88, 0xfc, 0x99, 0x6d, 0x2d, 0xf9, 0x85,
+        0x8d, 0x2c, 0x55, 0x36, 0x39, 0x93, 0xf0, 0x49, 0x4d, 0x7e, 0xc0,
+        0xbe, 0x5a, 0x56, 0x7b, 0x8a, 0x42, 0x43, 0xa5, 0x74, 0x5d};
diff --git a/crypto/fipsmodule/mlkem/mlkem.cc.inc b/crypto/fipsmodule/mlkem/mlkem.cc.inc
index c543f3c..265b0ca 100644
--- a/crypto/fipsmodule/mlkem/mlkem.cc.inc
+++ b/crypto/fipsmodule/mlkem/mlkem.cc.inc
@@ -26,12 +26,19 @@
 
 #include "../../internal.h"
 #include "../bcm_interface.h"
+#include "../delocate.h"
 #include "../keccak/internal.h"
 
 
 namespace mlkem {
 namespace {
 
+namespace fips {
+void ensure_keygen_self_test();
+void ensure_encap_self_test();
+void ensure_decap_self_test();
+}  // namespace fips
+
 // See
 // https://csrc.nist.gov/pubs/fips/203/final
 
@@ -690,7 +697,7 @@
 }
 
 template <int RANK>
-void mlkem_generate_key_external_seed(
+void mlkem_generate_key_external_seed_no_self_test(
     uint8_t *out_encoded_public_key, private_key<RANK> *priv,
     const uint8_t seed[BCM_MLKEM_SEED_BYTES]) {
   uint8_t augmented_seed[33];
@@ -727,6 +734,15 @@
   OPENSSL_memcpy(priv->fo_failure_secret, seed + 32, 32);
 }
 
+template <int RANK>
+void mlkem_generate_key_external_seed(
+    uint8_t *out_encoded_public_key, private_key<RANK> *priv,
+    const uint8_t seed[BCM_MLKEM_SEED_BYTES]) {
+  fips::ensure_keygen_self_test();
+  mlkem_generate_key_external_seed_no_self_test(out_encoded_public_key, priv,
+                                                seed);
+}
+
 // Encrypts a message with given randomness to
 // the ciphertext in |out|. Without applying the Fujisaki-Okamoto transform this
 // would not result in a CCA secure scheme, since lattice schemes are vulnerable
@@ -768,9 +784,9 @@
 
 // See section 6.3
 template <int RANK>
-void mlkem_decap(uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
-                 const uint8_t *ciphertext,
-                 const struct private_key<RANK> *priv) {
+void mlkem_decap_no_self_test(
+    uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
+    const uint8_t *ciphertext, const struct private_key<RANK> *priv) {
   uint8_t decrypted[64];
   decrypt_cpa(decrypted, priv, ciphertext);
   OPENSSL_memcpy(decrypted + 32, priv->pub.public_key_hash,
@@ -794,6 +810,14 @@
   }
 }
 
+template <int RANK>
+void mlkem_decap(uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
+                 const uint8_t *ciphertext,
+                 const struct private_key<RANK> *priv) {
+  fips::ensure_decap_self_test();
+  mlkem_decap_no_self_test(out_shared_secret, ciphertext, priv);
+}
+
 // mlkem_parse_public_key_no_hash parses |in| into |pub| but doesn't calculate
 // the value of |pub->public_key_hash|.
 template <int RANK>
@@ -863,8 +887,8 @@
   return (struct public_key<RANK768> *)external;
 }
 
-static struct public_key<RANK1024> *
-public_key_1024_from_external(const struct BCM_mlkem1024_public_key *external) {
+static struct public_key<RANK1024> *public_key_1024_from_external(
+    const struct BCM_mlkem1024_public_key *external) {
   static_assert(sizeof(struct BCM_mlkem1024_public_key) >=
                     sizeof(struct public_key<RANK1024>),
                 "MLKEM1024 public key is too small");
@@ -874,8 +898,8 @@
   return (struct public_key<RANK1024> *)external;
 }
 
-struct private_key<RANK768> *
-private_key_768_from_external(const struct BCM_mlkem768_private_key *external) {
+struct private_key<RANK768> *private_key_768_from_external(
+    const struct BCM_mlkem768_private_key *external) {
   static_assert(sizeof(struct BCM_mlkem768_private_key) >=
                     sizeof(struct private_key<RANK768>),
                 "MLKEM private key too small");
@@ -885,8 +909,7 @@
   return (struct private_key<RANK768> *)external;
 }
 
-struct private_key<RANK1024> *
-private_key_1024_from_external(
+struct private_key<RANK1024> *private_key_1024_from_external(
     const struct BCM_mlkem1024_private_key *external) {
   static_assert(sizeof(struct BCM_mlkem1024_private_key) >=
                     sizeof(struct private_key<RANK1024>),
@@ -897,9 +920,193 @@
   return (struct private_key<RANK1024> *)external;
 }
 
+// See section 6.2.
+template <int RANK>
+void mlkem_encap_external_entropy_no_self_test(
+    uint8_t *out_ciphertext,
+    uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
+    const struct mlkem::public_key<RANK> *pub,
+    const uint8_t entropy[BCM_MLKEM_ENCAP_ENTROPY]) {
+  uint8_t input[64];
+  OPENSSL_memcpy(input, entropy, BCM_MLKEM_ENCAP_ENTROPY);
+  OPENSSL_memcpy(input + BCM_MLKEM_ENCAP_ENTROPY, pub->public_key_hash,
+                 sizeof(input) - BCM_MLKEM_ENCAP_ENTROPY);
+  uint8_t key_and_randomness[64];
+  mlkem::hash_g(key_and_randomness, input, sizeof(input));
+  encrypt_cpa(out_ciphertext, pub, entropy, key_and_randomness + 32);
+  // The ciphertext is public.
+  CONSTTIME_DECLASSIFY(out_ciphertext, mlkem::ciphertext_size(RANK));
+  static_assert(BCM_MLKEM_SHARED_SECRET_BYTES == 32, "");
+  memcpy(out_shared_secret, key_and_randomness, 32);
+}
+
+template <int RANK>
+void mlkem_encap_external_entropy(
+    uint8_t *out_ciphertext,
+    uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
+    const struct mlkem::public_key<RANK> *pub,
+    const uint8_t entropy[BCM_MLKEM_ENCAP_ENTROPY]) {
+  fips::ensure_encap_self_test();
+  mlkem_encap_external_entropy_no_self_test(out_ciphertext, out_shared_secret,
+                                            pub, entropy);
+}
+
+namespace fips {
+
+#include "fips_known_values.inc"
+
+static int keygen_self_test() {
+  uint8_t pub_key[BCM_MLKEM768_PUBLIC_KEY_BYTES];
+  private_key<RANK768> priv;
+  static_assert(sizeof(kTestEntropy) >= BCM_MLKEM_SEED_BYTES);
+  mlkem_generate_key_external_seed_no_self_test(pub_key, &priv, kTestEntropy);
+  CBB cbb;
+  constexpr size_t kMarshaledPrivateKeySize = 2400;
+  uint8_t priv_bytes[kMarshaledPrivateKeySize];
+  CBB_init_fixed(&cbb, priv_bytes, sizeof(priv_bytes));
+  static_assert(sizeof(kExpectedPrivateKeyBytes) == kMarshaledPrivateKeySize);
+  static_assert(sizeof(kExpectedPublicKeyBytes) == sizeof(pub_key));
+  if (!mlkem_marshal_private_key(&cbb, &priv) ||
+      !BORINGSSL_check_test(kExpectedPrivateKeyBytes, priv_bytes,
+                            sizeof(priv_bytes), "ML-KEM keygen private key") ||
+      !BORINGSSL_check_test(kExpectedPublicKeyBytes, pub_key, sizeof(pub_key),
+                            "ML-KEM keygen public key")) {
+    return 0;
+  }
+  return 1;
+}
+
+static int encap_self_test() {
+  CBS cbs;
+  CBS_init(&cbs, kExpectedPublicKeyBytes, sizeof(kExpectedPublicKeyBytes));
+  public_key<RANK768> pub;
+  if (!mlkem_parse_public_key(&pub, &cbs)) {
+    return 0;
+  }
+  uint8_t ciphertext[BCM_MLKEM768_CIPHERTEXT_BYTES];
+  uint8_t shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES];
+  static_assert(sizeof(kTestEntropy) >= BCM_MLKEM_ENCAP_ENTROPY);
+  mlkem_encap_external_entropy_no_self_test(ciphertext, shared_secret, &pub,
+                                            kTestEntropy);
+  if (!BORINGSSL_check_test(ciphertext, kExpectedCiphertext, sizeof(ciphertext),
+                            "ML-KEM encap ciphertext") ||
+      !BORINGSSL_check_test(kExpectedSharedSecret, shared_secret,
+                            sizeof(kExpectedSharedSecret),
+                            "ML-KEM encap shared secret")) {
+    return 0;
+  }
+  return 1;
+}
+
+static int decap_self_test() {
+  CBS cbs;
+  CBS_init(&cbs, kExpectedPrivateKeyBytes, sizeof(kExpectedPrivateKeyBytes));
+  private_key<RANK768> priv;
+  if (!mlkem_parse_private_key(&priv, &cbs)) {
+    return 0;
+  }
+  uint8_t shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES];
+  mlkem_decap_no_self_test(shared_secret, kExpectedCiphertext, &priv);
+  static_assert(sizeof(kExpectedSharedSecret) == sizeof(shared_secret));
+  if (!BORINGSSL_check_test(kExpectedSharedSecret, shared_secret,
+                            sizeof(shared_secret),
+                            "ML-KEM decap shared secret")) {
+    return 0;
+  }
+
+  uint8_t implicit_rejection_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES];
+  static_assert(sizeof(kExpectedPrivateKeyBytes) >=
+                sizeof(kExpectedCiphertext));
+  mlkem_decap_no_self_test(implicit_rejection_shared_secret,
+                           kExpectedPrivateKeyBytes, &priv);
+  static_assert(sizeof(kExpectedImplicitRejectionSharedSecret) ==
+                sizeof(implicit_rejection_shared_secret));
+  if (!BORINGSSL_check_test(kExpectedImplicitRejectionSharedSecret,
+                            implicit_rejection_shared_secret,
+                            sizeof(implicit_rejection_shared_secret),
+                            "ML-KEM decap implicit rejection shared secret")) {
+    return 0;
+  }
+  return 1;
+}
+
+#if defined(BORINGSSL_FIPS)
+
+DEFINE_STATIC_ONCE(g_mlkem_keygen_self_test_once)
+
+void ensure_keygen_self_test(void) {
+  CRYPTO_once(g_mlkem_keygen_self_test_once_bss_get(), []() {
+    if (!keygen_self_test()) {
+      BORINGSSL_FIPS_abort();
+    }
+  });
+}
+
+DEFINE_STATIC_ONCE(g_mlkem_encap_self_test_once)
+
+void ensure_encap_self_test(void) {
+  CRYPTO_once(g_mlkem_encap_self_test_once_bss_get(), []() {
+    if (!encap_self_test()) {
+      BORINGSSL_FIPS_abort();
+    }
+  });
+}
+
+DEFINE_STATIC_ONCE(g_mlkem_decap_self_test_once)
+
+void ensure_decap_self_test(void) {
+  CRYPTO_once(g_mlkem_decap_self_test_once_bss_get(), []() {
+    if (!decap_self_test()) {
+      BORINGSSL_FIPS_abort();
+    }
+  });
+}
+
+#else
+
+void ensure_keygen_self_test(void) {}
+void ensure_encap_self_test(void) {}
+void ensure_decap_self_test(void) {}
+
+#endif
+}  // namespace fips
+
 }  // namespace
 }  // namespace mlkem
 
+bcm_status BCM_mlkem768_check_fips(
+    const struct BCM_mlkem768_private_key *private_key) {
+  mlkem::private_key<RANK768> *priv =
+      mlkem::private_key_768_from_external(private_key);
+
+  const uint8_t entropy[BCM_MLKEM_ENCAP_ENTROPY] = {1, 2, 3, 4};
+  uint8_t ciphertext[BCM_MLKEM768_CIPHERTEXT_BYTES];
+  uint8_t shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES];
+  mlkem_encap_external_entropy_no_self_test(ciphertext, shared_secret,
+                                            &priv->pub, entropy);
+
+  if (boringssl_fips_break_test("MLKEM_PWCT")) {
+    shared_secret[0] ^= 1;
+  }
+
+  uint8_t shared_secret2[BCM_MLKEM_SHARED_SECRET_BYTES];
+  mlkem::mlkem_decap_no_self_test(shared_secret2, ciphertext, priv);
+  if (CRYPTO_memcmp(shared_secret, shared_secret2, sizeof(shared_secret)) !=
+      0) {
+    return bcm_status::failure;
+  }
+  return bcm_status::approved;
+}
+
+bcm_status BCM_mlkem768_generate_key_fips(
+    uint8_t out_encoded_public_key[BCM_MLKEM768_PUBLIC_KEY_BYTES],
+    uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
+    struct BCM_mlkem768_private_key *out_private_key) {
+  BCM_mlkem768_generate_key(out_encoded_public_key, optional_out_seed,
+                            out_private_key);
+  return BCM_mlkem768_check_fips(out_private_key);
+}
+
 bcm_infallible BCM_mlkem768_generate_key(
     uint8_t out_encoded_public_key[BCM_MLKEM768_PUBLIC_KEY_BYTES],
     uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
@@ -912,7 +1119,7 @@
   }
   BCM_mlkem768_generate_key_external_seed(out_encoded_public_key,
                                           out_private_key, seed);
-  return bcm_infallible::approved;
+  return bcm_infallible::not_approved;
 }
 
 bcm_status BCM_mlkem768_private_key_from_seed(
@@ -921,12 +1128,46 @@
   if (seed_len != BCM_MLKEM_SEED_BYTES) {
     return bcm_status::failure;
   }
+
   uint8_t public_key_bytes[BCM_MLKEM768_PUBLIC_KEY_BYTES];
   BCM_mlkem768_generate_key_external_seed(public_key_bytes, out_private_key,
                                           seed);
+  return bcm_status::not_approved;
+}
+
+bcm_status BCM_mlkem1024_check_fips(
+    const struct BCM_mlkem1024_private_key *private_key) {
+  mlkem::private_key<RANK1024> *priv =
+      mlkem::private_key_1024_from_external(private_key);
+
+  const uint8_t entropy[BCM_MLKEM_ENCAP_ENTROPY] = {1, 2, 3, 4};
+  uint8_t ciphertext[BCM_MLKEM1024_CIPHERTEXT_BYTES];
+  uint8_t shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES];
+  mlkem_encap_external_entropy_no_self_test(ciphertext, shared_secret,
+                                            &priv->pub, entropy);
+
+  if (boringssl_fips_break_test("MLKEM_PWCT")) {
+    shared_secret[0] ^= 1;
+  }
+
+  uint8_t shared_secret2[BCM_MLKEM_SHARED_SECRET_BYTES];
+  mlkem::mlkem_decap_no_self_test(shared_secret2, ciphertext, priv);
+  if (CRYPTO_memcmp(shared_secret, shared_secret2, sizeof(shared_secret)) !=
+      0) {
+    return bcm_status::failure;
+  }
   return bcm_status::approved;
 }
 
+bcm_status BCM_mlkem1024_generate_key_fips(
+    uint8_t out_encoded_public_key[BCM_MLKEM1024_PUBLIC_KEY_BYTES],
+    uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
+    struct BCM_mlkem1024_private_key *out_private_key) {
+  BCM_mlkem1024_generate_key(out_encoded_public_key, optional_out_seed,
+                             out_private_key);
+  return BCM_mlkem1024_check_fips(out_private_key);
+}
+
 bcm_infallible BCM_mlkem1024_generate_key(
     uint8_t out_encoded_public_key[BCM_MLKEM1024_PUBLIC_KEY_BYTES],
     uint8_t optional_out_seed[BCM_MLKEM_SEED_BYTES],
@@ -939,7 +1180,7 @@
   }
   BCM_mlkem1024_generate_key_external_seed(out_encoded_public_key,
                                            out_private_key, seed);
-  return bcm_infallible::approved;
+  return bcm_infallible::not_approved;
 }
 
 bcm_status BCM_mlkem1024_private_key_from_seed(
@@ -951,7 +1192,7 @@
   uint8_t public_key_bytes[BCM_MLKEM1024_PUBLIC_KEY_BYTES];
   BCM_mlkem1024_generate_key_external_seed(public_key_bytes, out_private_key,
                                            seed);
-  return bcm_status::approved;
+  return bcm_status::not_approved;
 }
 
 bcm_infallible BCM_mlkem768_generate_key_external_seed(
@@ -1022,26 +1263,6 @@
   return bcm_infallible::approved;
 }
 
-// See section 6.2.
-template <int RANK>
-void mlkem_encap_external_entropy(
-    uint8_t *out_ciphertext,
-    uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
-    const struct mlkem::public_key<RANK> *pub,
-    const uint8_t entropy[BCM_MLKEM_ENCAP_ENTROPY]) {
-  uint8_t input[64];
-  OPENSSL_memcpy(input, entropy, BCM_MLKEM_ENCAP_ENTROPY);
-  OPENSSL_memcpy(input + BCM_MLKEM_ENCAP_ENTROPY, pub->public_key_hash,
-                 sizeof(input) - BCM_MLKEM_ENCAP_ENTROPY);
-  uint8_t key_and_randomness[64];
-  mlkem::hash_g(key_and_randomness, input, sizeof(input));
-  encrypt_cpa(out_ciphertext, pub, entropy, key_and_randomness + 32);
-  // The ciphertext is public.
-  CONSTTIME_DECLASSIFY(out_ciphertext, mlkem::ciphertext_size(RANK));
-  static_assert(BCM_MLKEM_SHARED_SECRET_BYTES == 32, "");
-  memcpy(out_shared_secret, key_and_randomness, 32);
-}
-
 bcm_infallible BCM_mlkem768_encap_external_entropy(
     uint8_t out_ciphertext[BCM_MLKEM768_CIPHERTEXT_BYTES],
     uint8_t out_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES],
@@ -1163,3 +1384,8 @@
   }
   return bcm_status::approved;
 }
+
+int boringssl_self_test_mlkem() {
+  return mlkem::fips::keygen_self_test() && mlkem::fips::encap_self_test() &&
+         mlkem::fips::decap_self_test();
+}
diff --git a/crypto/fipsmodule/self_check/self_check.cc.inc b/crypto/fipsmodule/self_check/self_check.cc.inc
index 15a68b5..c3b77d4 100644
--- a/crypto/fipsmodule/self_check/self_check.cc.inc
+++ b/crypto/fipsmodule/self_check/self_check.cc.inc
@@ -44,14 +44,6 @@
 #include "../tls/internal.h"
 
 
-// MSVC wants to put a NUL byte at the end of non-char arrays and so cannot
-// compile the real logic.
-#if defined(_MSC_VER)
-
-int BORINGSSL_self_test(void) { return 0; }
-
-#else
-
 static void hexdump(FILE *out, const void *in, size_t len) {
   const uint8_t *in8 = reinterpret_cast<const uint8_t *>(in);
   for (size_t i = 0; i < len; i++) {
@@ -59,8 +51,8 @@
   }
 }
 
-static int check_test(const void *expected, const void *actual,
-                      size_t expected_len, const char *name) {
+int BORINGSSL_check_test(const void *expected, const void *actual,
+                         size_t expected_len, const char *name) {
   if (OPENSSL_memcmp(actual, expected, expected_len) != 0) {
     FILE *err = CRYPTO_get_stderr();
     fprintf(err, "%s failed.\nExpected:   ", name);
@@ -74,6 +66,14 @@
   return 1;
 }
 
+// MSVC wants to put a NUL byte at the end of non-char arrays and so cannot
+// compile the real logic.
+#if defined(_MSC_VER)
+
+int BORINGSSL_self_test(void) { return 0; }
+
+#else
+
 static int set_bignum(BIGNUM **out, const uint8_t *in, size_t len) {
   *out = BN_bin2bn(in, len, NULL);
   return *out != NULL;
@@ -337,8 +337,8 @@
   unsigned sig_len;
   if (!rsa_sign_no_self_test(NID_sha256, kRSASignDigest, sizeof(kRSASignDigest),
                              output, &sig_len, rsa_key) ||
-      !check_test(kRSASignSignature, output, sizeof(kRSASignSignature),
-                  "RSA-sign KAT")) {
+      !BORINGSSL_check_test(kRSASignSignature, output,
+                            sizeof(kRSASignSignature), "RSA-sign KAT")) {
     fprintf(CRYPTO_get_stderr(), "RSA signing test failed.\n");
     goto err;
   }
@@ -429,8 +429,9 @@
           kECDSASignDigest, sizeof(kECDSASignDigest), ecdsa_sign_output,
           &ecdsa_sign_output_len, sizeof(ecdsa_sign_output), ec_key, ecdsa_k,
           sizeof(ecdsa_k)) ||
-      !check_test(kECDSASignSig, ecdsa_sign_output, sizeof(ecdsa_sign_output),
-                  "ECDSA-sign signature")) {
+      !BORINGSSL_check_test(kECDSASignSig, ecdsa_sign_output,
+                            sizeof(ecdsa_sign_output),
+                            "ECDSA-sign signature")) {
     fprintf(CRYPTO_get_stderr(), "ECDSA-sign KAT failed.\n");
     goto err;
   }
@@ -496,8 +497,8 @@
                                  ec_scalar, NULL) ||
       !EC_POINT_point2oct(ec_group, ec_point_out, POINT_CONVERSION_UNCOMPRESSED,
                           z_comp_result, sizeof(z_comp_result), NULL) ||
-      !check_test(kP256PointResult, z_comp_result, sizeof(z_comp_result),
-                  "Z Computation Result")) {
+      !BORINGSSL_check_test(kP256PointResult, z_comp_result,
+                            sizeof(z_comp_result), "Z Computation Result")) {
     fprintf(CRYPTO_get_stderr(), "Z-computation KAT failed.\n");
     goto err;
   }
@@ -576,7 +577,7 @@
   if (dh == NULL || ffdhe2048_value == NULL || sizeof(dh_out) != DH_size(dh) ||
       dh_compute_key_padded_no_self_test(dh_out, ffdhe2048_value, dh) !=
           sizeof(dh_out) ||
-      !check_test(kDHOutput, dh_out, sizeof(dh_out), "FFC DH")) {
+      !BORINGSSL_check_test(kDHOutput, dh_out, sizeof(dh_out), "FFC DH")) {
     fprintf(CRYPTO_get_stderr(), "FFDH failed.\n");
     goto err;
   }
@@ -655,8 +656,8 @@
 
   // SHA-256 KAT
   SHA256(kInput, sizeof(kInput), output);
-  return check_test(kPlaintextSHA256, output, sizeof(kPlaintextSHA256),
-                    "SHA-256 KAT");
+  return BORINGSSL_check_test(kPlaintextSHA256, output,
+                              sizeof(kPlaintextSHA256), "SHA-256 KAT");
 }
 
 int boringssl_self_test_sha512(void) {
@@ -676,8 +677,8 @@
 
   // SHA-512 KAT
   SHA512(kInput, sizeof(kInput), output);
-  return check_test(kPlaintextSHA512, output, sizeof(kPlaintextSHA512),
-                    "SHA-512 KAT");
+  return BORINGSSL_check_test(kPlaintextSHA512, output,
+                              sizeof(kPlaintextSHA512), "SHA-512 KAT");
 }
 
 int boringssl_self_test_hmac_sha256(void) {
@@ -696,8 +697,8 @@
   HMAC(EVP_sha256(), kInput, sizeof(kInput), kInput, sizeof(kInput), output,
        &output_len);
   return output_len == sizeof(kPlaintextHMACSHA256) &&
-         check_test(kPlaintextHMACSHA256, output, sizeof(kPlaintextHMACSHA256),
-                    "HMAC-SHA-256 KAT");
+         BORINGSSL_check_test(kPlaintextHMACSHA256, output,
+                              sizeof(kPlaintextHMACSHA256), "HMAC-SHA-256 KAT");
 }
 
 static int boringssl_self_test_fast(void) {
@@ -733,8 +734,9 @@
   }
   AES_cbc_encrypt(kAESCBCEncPlaintext, output, sizeof(kAESCBCEncPlaintext),
                   &aes_key, aes_iv, AES_ENCRYPT);
-  if (!check_test(kAESCBCEncCiphertext, output, sizeof(kAESCBCEncCiphertext),
-                  "AES-CBC-encrypt KAT")) {
+  if (!BORINGSSL_check_test(kAESCBCEncCiphertext, output,
+                            sizeof(kAESCBCEncCiphertext),
+                            "AES-CBC-encrypt KAT")) {
     goto err;
   }
 
@@ -756,8 +758,9 @@
   }
   AES_cbc_encrypt(kAESCBCDecCiphertext, output, sizeof(kAESCBCDecCiphertext),
                   &aes_key, aes_iv, AES_DECRYPT);
-  if (!check_test(kAESCBCDecPlaintext, output, sizeof(kAESCBCDecPlaintext),
-                  "AES-CBC-decrypt KAT")) {
+  if (!BORINGSSL_check_test(kAESCBCDecPlaintext, output,
+                            sizeof(kAESCBCDecPlaintext),
+                            "AES-CBC-decrypt KAT")) {
     goto err;
   }
 
@@ -786,8 +789,8 @@
                          EVP_AEAD_nonce_length(EVP_aead_aes_128_gcm()),
                          kAESGCMEncPlaintext, sizeof(kAESGCMEncPlaintext), NULL,
                          0) ||
-      !check_test(kAESGCMCiphertext, output, sizeof(kAESGCMCiphertext),
-                  "AES-GCM-encrypt KAT")) {
+      !BORINGSSL_check_test(kAESGCMCiphertext, output,
+                            sizeof(kAESGCMCiphertext), "AES-GCM-encrypt KAT")) {
     fprintf(CRYPTO_get_stderr(), "EVP_AEAD_CTX_seal for AES-128-GCM failed.\n");
     goto err;
   }
@@ -809,8 +812,9 @@
                          EVP_AEAD_nonce_length(EVP_aead_aes_128_gcm()),
                          kAESGCMDecCiphertext, sizeof(kAESGCMDecCiphertext),
                          NULL, 0) ||
-      !check_test(kAESGCMDecPlaintext, output, sizeof(kAESGCMDecPlaintext),
-                  "AES-GCM-decrypt KAT")) {
+      !BORINGSSL_check_test(kAESGCMDecPlaintext, output,
+                            sizeof(kAESGCMDecPlaintext),
+                            "AES-GCM-decrypt KAT")) {
     fprintf(CRYPTO_get_stderr(),
             "AES-GCM-decrypt KAT failed because EVP_AEAD_CTX_open failed.\n");
     goto err;
@@ -826,7 +830,8 @@
       0x09, 0x11, 0x6d, 0x1a, 0xfd, 0x0f, 0x1e, 0x11, 0xe3, 0xcb,
   };
   SHA1(kSHA1Input, sizeof(kSHA1Input), output);
-  if (!check_test(kSHA1Digest, output, sizeof(kSHA1Digest), "SHA-1 KAT")) {
+  if (!BORINGSSL_check_test(kSHA1Digest, output, sizeof(kSHA1Digest),
+                            "SHA-1 KAT")) {
     goto err;
   }
 
@@ -874,13 +879,13 @@
                      sizeof(kDRBGPersonalization)) ||
       !CTR_DRBG_generate(&drbg, output, sizeof(kDRBGOutput), kDRBGAD,
                          sizeof(kDRBGAD)) ||
-      !check_test(kDRBGOutput, output, sizeof(kDRBGOutput),
-                  "DRBG Generate KAT") ||
+      !BORINGSSL_check_test(kDRBGOutput, output, sizeof(kDRBGOutput),
+                            "DRBG Generate KAT") ||
       !CTR_DRBG_reseed(&drbg, kDRBGEntropy2, kDRBGAD, sizeof(kDRBGAD)) ||
       !CTR_DRBG_generate(&drbg, output, sizeof(kDRBGReseedOutput), kDRBGAD,
                          sizeof(kDRBGAD)) ||
-      !check_test(kDRBGReseedOutput, output, sizeof(kDRBGReseedOutput),
-                  "DRBG-reseed KAT")) {
+      !BORINGSSL_check_test(kDRBGReseedOutput, output,
+                            sizeof(kDRBGReseedOutput), "DRBG-reseed KAT")) {
     fprintf(CRYPTO_get_stderr(), "CTR-DRBG failed.\n");
     goto err;
   }
@@ -888,7 +893,8 @@
 
   CTR_DRBG_STATE kZeroDRBG;
   memset(&kZeroDRBG, 0, sizeof(kZeroDRBG));
-  if (!check_test(&kZeroDRBG, &drbg, sizeof(drbg), "DRBG Clear KAT")) {
+  if (!BORINGSSL_check_test(&kZeroDRBG, &drbg, sizeof(drbg),
+                            "DRBG Clear KAT")) {
     goto err;
   }
 
@@ -918,8 +924,8 @@
                        kTLS10Secret, sizeof(kTLS10Secret), kTLSLabel,
                        sizeof(kTLSLabel), kTLSSeed1, sizeof(kTLSSeed1),
                        kTLSSeed2, sizeof(kTLSSeed2)) ||
-      !check_test(kTLS10Output, tls10_output, sizeof(kTLS10Output),
-                  "TLS10-KDF KAT")) {
+      !BORINGSSL_check_test(kTLS10Output, tls10_output, sizeof(kTLS10Output),
+                            "TLS10-KDF KAT")) {
     fprintf(CRYPTO_get_stderr(), "TLS KDF failed.\n");
     goto err;
   }
@@ -939,8 +945,8 @@
                        kTLS12Secret, sizeof(kTLS12Secret), kTLSLabel,
                        sizeof(kTLSLabel), kTLSSeed1, sizeof(kTLSSeed1),
                        kTLSSeed2, sizeof(kTLSSeed2)) ||
-      !check_test(kTLS12Output, tls12_output, sizeof(kTLS12Output),
-                  "TLS12-KDF KAT")) {
+      !BORINGSSL_check_test(kTLS12Output, tls12_output, sizeof(kTLS12Output),
+                            "TLS12-KDF KAT")) {
     fprintf(CRYPTO_get_stderr(), "TLS KDF failed.\n");
     goto err;
   }
@@ -978,9 +984,9 @@
           EVP_sha256(), tls13_extract_output, sizeof(tls13_extract_output),
           kTLS13Label, sizeof(kTLS13Label) - 1, kTLS13ClientHelloHash,
           sizeof(kTLS13ClientHelloHash)) ||
-      !check_test(kTLS13ExpandLabelOutput, tls13_expand_label_output,
-                  sizeof(kTLS13ExpandLabelOutput),
-                  "CRYPTO_tls13_hkdf_expand_label")) {
+      !BORINGSSL_check_test(kTLS13ExpandLabelOutput, tls13_expand_label_output,
+                            sizeof(kTLS13ExpandLabelOutput),
+                            "CRYPTO_tls13_hkdf_expand_label")) {
     fprintf(CRYPTO_get_stderr(), "TLS13-KDF failed.\n");
     goto err;
   }
@@ -1010,7 +1016,8 @@
   if (!HKDF(hkdf_output, sizeof(hkdf_output), EVP_sha256(), kHKDFSecret,
             sizeof(kHKDFSecret), kHKDFSalt, sizeof(kHKDFSalt), kHKDFInfo,
             sizeof(kHKDFInfo)) ||
-      !check_test(kHKDFOutput, hkdf_output, sizeof(kHKDFOutput), "HKDF")) {
+      !BORINGSSL_check_test(kHKDFOutput, hkdf_output, sizeof(kHKDFOutput),
+                            "HKDF")) {
     fprintf(CRYPTO_get_stderr(), "HKDF failed.\n");
     goto err;
   }
@@ -1026,9 +1033,10 @@
 int BORINGSSL_self_test(void) {
   if (!boringssl_self_test_fast() ||
       // When requested to run self tests, also run the lazy tests.
-      !boringssl_self_test_rsa() ||  //
-      !boringssl_self_test_ecc() ||  //
-      !boringssl_self_test_ffdh()) {
+      !boringssl_self_test_rsa() ||   //
+      !boringssl_self_test_ecc() ||   //
+      !boringssl_self_test_ffdh() ||  //
+      !boringssl_self_test_mlkem()) {
     return 0;
   }
 
diff --git a/crypto/internal.h b/crypto/internal.h
index 4b14217..2c9a65b 100644
--- a/crypto/internal.h
+++ b/crypto/internal.h
@@ -1048,6 +1048,12 @@
 
 #endif  // FIPS
 
+// BORINGSSL_check_test memcmp's two values of equal length. It returns 1 on
+// success and, on failure, it prints an error message that includes the
+// hexdumps the two values and returns 0.
+int BORINGSSL_check_test(const void *expected, const void *actual,
+                         size_t expected_len, const char *name);
+
 // boringssl_self_test_sha256 performs a SHA-256 KAT.
 int boringssl_self_test_sha256(void);
 
@@ -1057,6 +1063,9 @@
 // boringssl_self_test_hmac_sha256 performs an HMAC-SHA-256 KAT.
 int boringssl_self_test_hmac_sha256(void);
 
+// boringssl_self_test_mlkem performs the ML-KEM KATs.
+OPENSSL_EXPORT int boringssl_self_test_mlkem(void);
+
 #if defined(BORINGSSL_FIPS_COUNTERS)
 void boringssl_fips_inc_counter(enum fips_counter_t counter);
 #else
diff --git a/crypto/mlkem/mlkem_test.cc b/crypto/mlkem/mlkem_test.cc
index 0d8baaa..213991a 100644
--- a/crypto/mlkem/mlkem_test.cc
+++ b/crypto/mlkem/mlkem_test.cc
@@ -527,4 +527,21 @@
       0x04, 0xab, 0xdb, 0x94, 0x8b, 0x90, 0x8b, 0x75, 0xba, 0xd5};
   EXPECT_EQ(Bytes(result), Bytes(kExpected));
 }
+
+TEST(MLKEMTest, Self) { ASSERT_TRUE(boringssl_self_test_mlkem()); }
+
+TEST(MLKEMTest, PWCT) {
+  auto pub768 = std::make_unique<uint8_t[]>(BCM_MLKEM768_PUBLIC_KEY_BYTES);
+  auto priv768 = std::make_unique<BCM_mlkem768_private_key>();
+  ASSERT_EQ(
+      BCM_mlkem768_generate_key_fips(pub768.get(), nullptr, priv768.get()),
+      bcm_status::approved);
+
+  auto pub1024 = std::make_unique<uint8_t[]>(BCM_MLKEM1024_PUBLIC_KEY_BYTES);
+  auto priv1024 = std::make_unique<BCM_mlkem1024_private_key>();
+  ASSERT_EQ(
+      BCM_mlkem1024_generate_key_fips(pub1024.get(), nullptr, priv1024.get()),
+      bcm_status::approved);
+}
+
 }  // namespace
diff --git a/gen/sources.bzl b/gen/sources.bzl
index 082ac46..16050f5 100644
--- a/gen/sources.bzl
+++ b/gen/sources.bzl
@@ -80,6 +80,7 @@
     "crypto/fipsmodule/hmac/hmac.cc.inc",
     "crypto/fipsmodule/keccak/keccak.cc.inc",
     "crypto/fipsmodule/mldsa/mldsa.cc.inc",
+    "crypto/fipsmodule/mlkem/fips_known_values.inc",
     "crypto/fipsmodule/mlkem/mlkem.cc.inc",
     "crypto/fipsmodule/rand/ctrdrbg.cc.inc",
     "crypto/fipsmodule/rand/rand.cc.inc",
diff --git a/gen/sources.cmake b/gen/sources.cmake
index 5f4afc8..6109220 100644
--- a/gen/sources.cmake
+++ b/gen/sources.cmake
@@ -84,6 +84,7 @@
   crypto/fipsmodule/hmac/hmac.cc.inc
   crypto/fipsmodule/keccak/keccak.cc.inc
   crypto/fipsmodule/mldsa/mldsa.cc.inc
+  crypto/fipsmodule/mlkem/fips_known_values.inc
   crypto/fipsmodule/mlkem/mlkem.cc.inc
   crypto/fipsmodule/rand/ctrdrbg.cc.inc
   crypto/fipsmodule/rand/rand.cc.inc
diff --git a/gen/sources.gni b/gen/sources.gni
index 1cc825f..921bd13 100644
--- a/gen/sources.gni
+++ b/gen/sources.gni
@@ -80,6 +80,7 @@
   "crypto/fipsmodule/hmac/hmac.cc.inc",
   "crypto/fipsmodule/keccak/keccak.cc.inc",
   "crypto/fipsmodule/mldsa/mldsa.cc.inc",
+  "crypto/fipsmodule/mlkem/fips_known_values.inc",
   "crypto/fipsmodule/mlkem/mlkem.cc.inc",
   "crypto/fipsmodule/rand/ctrdrbg.cc.inc",
   "crypto/fipsmodule/rand/rand.cc.inc",
diff --git a/gen/sources.json b/gen/sources.json
index 239b0a8..ced1d06 100644
--- a/gen/sources.json
+++ b/gen/sources.json
@@ -65,6 +65,7 @@
       "crypto/fipsmodule/hmac/hmac.cc.inc",
       "crypto/fipsmodule/keccak/keccak.cc.inc",
       "crypto/fipsmodule/mldsa/mldsa.cc.inc",
+      "crypto/fipsmodule/mlkem/fips_known_values.inc",
       "crypto/fipsmodule/mlkem/mlkem.cc.inc",
       "crypto/fipsmodule/rand/ctrdrbg.cc.inc",
       "crypto/fipsmodule/rand/rand.cc.inc",
diff --git a/util/fipstools/break-kat.go b/util/fipstools/break-kat.go
index aafd1c3..54a544c 100644
--- a/util/fipstools/break-kat.go
+++ b/util/fipstools/break-kat.go
@@ -38,6 +38,9 @@
 		"DRBG":            "c4da0740d505f1ee280b95e58c4931ac6de846a0152fbb4a3f174cf4787a4f1a40c2b50babe14aae530be5886d910a27",
 		"DRBG-reseed":     "c7161ca36c2309b716e9859bb96c6d49bdc8352103a18cd24ef42ec97ef46bf446eb1a4576c186e9351803763a7912fe",
 		"HKDF":            "68678504b9b3add17d5967a1a7bd37993fd8a33ce7303071f39c096d1635b3c9",
+		"MLKEM-keygen":    "d8c9397c3130d8ecb411a68efcc89a553cb7e6817e0288bd0691609bf5",
+		"MLKEM-encap":     "7d9f1cb4ae04d75fa6575ae0e429b573a974b7",
+		"MLKEM-decap":     "a3192a8c88fc996d2df9858d2c55363993f0494d7ec0be5a567b8a4243a5745d",
 		"SHA-1":           "132fd9bad5c1826263bafbb699f707a5",
 		"SHA-256":         "ff3b857da7236a2baa0f396b51522217",
 		"SHA-512":         "212512f8d2ad8322781c6c4d69a9daa1",
@@ -88,6 +91,8 @@
 	}
 
 	for _, test := range sortedKATs() {
+		fmt.Printf("\n### Running test for %q\n\n", test)
+
 		const outFile = "test_fips_broken"
 		output, err := os.OpenFile(outFile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0755)
 		if err != nil {
@@ -96,7 +101,6 @@
 		breakBinary(binaryContents, test, output)
 		output.Close()
 
-		fmt.Printf("\n### Running test for %q\n\n", test)
 		cmd := exec.Command("./" + outFile)
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stdout
@@ -108,7 +112,7 @@
 		os.Remove(outFile)
 	}
 
-	for _, test := range []string{"ECDSA_PWCT", "RSA_PWCT", "CRNG"} {
+	for _, test := range []string{"ECDSA_PWCT", "RSA_PWCT", "MLKEM_PWCT", "CRNG"} {
 		fmt.Printf("\n### Running test for %q\n\n", test)
 
 		cmd := exec.Command("./" + inPath)
@@ -129,24 +133,28 @@
 		panic("invalid KAT data: " + err.Error())
 	}
 
-	i := bytes.Index(binaryContents, testInputValue)
-	if i < 0 {
-		fmt.Fprintln(os.Stderr, "Expected test input value for", test, "was not found in binary.")
-		os.Exit(3)
-	}
-
 	brokenContents := make([]byte, len(binaryContents))
 	copy(brokenContents, binaryContents)
 
-	// Zero out the entire value because the compiler may produce code
-	// where parts of the value are embedded in the instructions.
-	for j := range testInputValue {
-		brokenContents[i+j] = 0
+	found := false
+	for {
+		i := bytes.Index(brokenContents, testInputValue)
+		if i < 0 {
+			break
+		}
+		found = true
+
+		// Zero out the entire value because the compiler may produce code
+		// where parts of the value are embedded in the instructions.
+		// See crbug.com/399818730
+		for j := range testInputValue {
+			brokenContents[i+j] = 0
+		}
 	}
 
-	if bytes.Index(brokenContents, testInputValue) >= 0 {
-		fmt.Fprintln(os.Stderr, "Test input value was still found after erasing it. Second copy?")
-		os.Exit(4)
+	if !found {
+		fmt.Fprintln(os.Stderr, "Expected test input value for", test, "was not found in binary.")
+		os.Exit(3)
 	}
 
 	if n, err := output.Write(brokenContents); err != nil || n != len(brokenContents) {
diff --git a/util/fipstools/delocate/delocate.peg b/util/fipstools/delocate/delocate.peg
index 79dbe7f..8fac2d6 100644
--- a/util/fipstools/delocate/delocate.peg
+++ b/util/fipstools/delocate/delocate.peg
@@ -41,7 +41,7 @@
 FileDirective <- ".file" WS [^#\n]+
 LocDirective <- ".loc" WS [^#/\n]+
 Args <- Arg ((WS? ',' WS?) Arg)*
-Arg <- QuotedArg / [[0-9a-z%+\-*_@.]]*
+Arg <- QuotedArg / [[0-9a-z%+\-*_@.$]]*
 QuotedArg <- '"' QuotedText '"'
 QuotedText <- (EscapedChar / [^"])*
 LabelContainingDirective <- LabelContainingDirectiveName WS SymbolArgs
diff --git a/util/fipstools/delocate/delocate.peg.go b/util/fipstools/delocate/delocate.peg.go
index 7baa0e7..0f8ac01 100644
--- a/util/fipstools/delocate/delocate.peg.go
+++ b/util/fipstools/delocate/delocate.peg.go
@@ -364,6 +364,7 @@
 		return nil
 	}
 }
+
 func (p *Asm) Init(options ...func(*Asm) error) error {
 	var (
 		max                  token32
@@ -1246,7 +1247,7 @@
 			position, tokenIndex = position110, tokenIndex110
 			return false
 		},
-		/* 9 Arg <- <(QuotedArg / ([0-9] / [0-9] / ([a-z] / [A-Z]) / '%' / '+' / '-' / '*' / '_' / '@' / '.')*)> */
+		/* 9 Arg <- <(QuotedArg / ([0-9] / [0-9] / ([a-z] / [A-Z]) / '%' / '+' / '-' / '*' / '_' / '@' / '.' / '$')*)> */
 		func() bool {
 			{
 				position119 := position
@@ -1338,6 +1339,13 @@
 						l135:
 							position, tokenIndex = position124, tokenIndex124
 							if buffer[position] != rune('.') {
+								goto l136
+							}
+							position++
+							goto l124
+						l136:
+							position, tokenIndex = position124, tokenIndex124
+							if buffer[position] != rune('$') {
 								goto l123
 							}
 							position++
@@ -1355,6304 +1363,6304 @@
 		},
 		/* 10 QuotedArg <- <('"' QuotedText '"')> */
 		func() bool {
-			position136, tokenIndex136 := position, tokenIndex
+			position137, tokenIndex137 := position, tokenIndex
 			{
-				position137 := position
+				position138 := position
 				if buffer[position] != rune('"') {
-					goto l136
+					goto l137
 				}
 				position++
 				if !_rules[ruleQuotedText]() {
-					goto l136
+					goto l137
 				}
 				if buffer[position] != rune('"') {
-					goto l136
+					goto l137
 				}
 				position++
-				add(ruleQuotedArg, position137)
+				add(ruleQuotedArg, position138)
 			}
 			return true
-		l136:
-			position, tokenIndex = position136, tokenIndex136
+		l137:
+			position, tokenIndex = position137, tokenIndex137
 			return false
 		},
 		/* 11 QuotedText <- <(EscapedChar / (!'"' .))*> */
 		func() bool {
 			{
-				position139 := position
-			l140:
+				position140 := position
+			l141:
 				{
-					position141, tokenIndex141 := position, tokenIndex
+					position142, tokenIndex142 := position, tokenIndex
 					{
-						position142, tokenIndex142 := position, tokenIndex
+						position143, tokenIndex143 := position, tokenIndex
 						if !_rules[ruleEscapedChar]() {
-							goto l143
+							goto l144
 						}
-						goto l142
-					l143:
-						position, tokenIndex = position142, tokenIndex142
+						goto l143
+					l144:
+						position, tokenIndex = position143, tokenIndex143
 						{
-							position144, tokenIndex144 := position, tokenIndex
+							position145, tokenIndex145 := position, tokenIndex
 							if buffer[position] != rune('"') {
-								goto l144
+								goto l145
 							}
 							position++
-							goto l141
-						l144:
-							position, tokenIndex = position144, tokenIndex144
+							goto l142
+						l145:
+							position, tokenIndex = position145, tokenIndex145
 						}
 						if !matchDot() {
-							goto l141
+							goto l142
 						}
 					}
+				l143:
+					goto l141
 				l142:
-					goto l140
-				l141:
-					position, tokenIndex = position141, tokenIndex141
+					position, tokenIndex = position142, tokenIndex142
 				}
-				add(ruleQuotedText, position139)
+				add(ruleQuotedText, position140)
 			}
 			return true
 		},
 		/* 12 LabelContainingDirective <- <(LabelContainingDirectiveName WS SymbolArgs)> */
 		func() bool {
-			position145, tokenIndex145 := position, tokenIndex
+			position146, tokenIndex146 := position, tokenIndex
 			{
-				position146 := position
+				position147 := position
 				if !_rules[ruleLabelContainingDirectiveName]() {
-					goto l145
+					goto l146
 				}
 				if !_rules[ruleWS]() {
-					goto l145
+					goto l146
 				}
 				if !_rules[ruleSymbolArgs]() {
-					goto l145
+					goto l146
 				}
-				add(ruleLabelContainingDirective, position146)
+				add(ruleLabelContainingDirective, position147)
 			}
 			return true
-		l145:
-			position, tokenIndex = position145, tokenIndex145
+		l146:
+			position, tokenIndex = position146, tokenIndex146
 			return false
 		},
 		/* 13 LabelContainingDirectiveName <- <(('.' ('x' / 'X') ('w' / 'W') ('o' / 'O') ('r' / 'R') ('d' / 'D')) / ('.' ('w' / 'W') ('o' / 'O') ('r' / 'R') ('d' / 'D')) / ('.' ('h' / 'H') ('w' / 'W') ('o' / 'O') ('r' / 'R') ('d' / 'D')) / ('.' ('l' / 'L') ('o' / 'O') ('n' / 'N') ('g' / 'G')) / ('.' ('s' / 'S') ('e' / 'E') ('t' / 'T')) / ('.' ('b' / 'B') ('y' / 'Y') ('t' / 'T') ('e' / 'E')) / ('.' '8' ('b' / 'B') ('y' / 'Y') ('t' / 'T') ('e' / 'E')) / ('.' '4' ('b' / 'B') ('y' / 'Y') ('t' / 'T') ('e' / 'E')) / ('.' ('q' / 'Q') ('u' / 'U') ('a' / 'A') ('d' / 'D')) / ('.' ('t' / 'T') ('c' / 'C')) / ('.' ('l' / 'L') ('o' / 'O') ('c' / 'C') ('a' / 'A') ('l' / 'L') ('e' / 'E') ('n' / 'N') ('t' / 'T') ('r' / 'R') ('y' / 'Y')) / ('.' ('s' / 'S') ('i' / 'I') ('z' / 'Z') ('e' / 'E')) / ('.' ('t' / 'T') ('y' / 'Y') ('p' / 'P') ('e' / 'E')) / ('.' ('u' / 'U') ('l' / 'L') ('e' / 'E') ('b' / 'B') '1' '2' '8') / ('.' ('s' / 'S') ('l' / 'L') ('e' / 'E') ('b' / 'B') '1' '2' '8'))> */
 		func() bool {
-			position147, tokenIndex147 := position, tokenIndex
+			position148, tokenIndex148 := position, tokenIndex
 			{
-				position148 := position
+				position149 := position
 				{
-					position149, tokenIndex149 := position, tokenIndex
+					position150, tokenIndex150 := position, tokenIndex
 					if buffer[position] != rune('.') {
-						goto l150
-					}
-					position++
-					{
-						position151, tokenIndex151 := position, tokenIndex
-						if buffer[position] != rune('x') {
-							goto l152
-						}
-						position++
 						goto l151
-					l152:
-						position, tokenIndex = position151, tokenIndex151
+					}
+					position++
+					{
+						position152, tokenIndex152 := position, tokenIndex
+						if buffer[position] != rune('x') {
+							goto l153
+						}
+						position++
+						goto l152
+					l153:
+						position, tokenIndex = position152, tokenIndex152
 						if buffer[position] != rune('X') {
-							goto l150
+							goto l151
 						}
 						position++
 					}
+				l152:
+					{
+						position154, tokenIndex154 := position, tokenIndex
+						if buffer[position] != rune('w') {
+							goto l155
+						}
+						position++
+						goto l154
+					l155:
+						position, tokenIndex = position154, tokenIndex154
+						if buffer[position] != rune('W') {
+							goto l151
+						}
+						position++
+					}
+				l154:
+					{
+						position156, tokenIndex156 := position, tokenIndex
+						if buffer[position] != rune('o') {
+							goto l157
+						}
+						position++
+						goto l156
+					l157:
+						position, tokenIndex = position156, tokenIndex156
+						if buffer[position] != rune('O') {
+							goto l151
+						}
+						position++
+					}
+				l156:
+					{
+						position158, tokenIndex158 := position, tokenIndex
+						if buffer[position] != rune('r') {
+							goto l159
+						}
+						position++
+						goto l158
+					l159:
+						position, tokenIndex = position158, tokenIndex158
+						if buffer[position] != rune('R') {
+							goto l151
+						}
+						position++
+					}
+				l158:
+					{
+						position160, tokenIndex160 := position, tokenIndex
+						if buffer[position] != rune('d') {
+							goto l161
+						}
+						position++
+						goto l160
+					l161:
+						position, tokenIndex = position160, tokenIndex160
+						if buffer[position] != rune('D') {
+							goto l151
+						}
+						position++
+					}
+				l160:
+					goto l150
 				l151:
-					{
-						position153, tokenIndex153 := position, tokenIndex
-						if buffer[position] != rune('w') {
-							goto l154
-						}
-						position++
-						goto l153
-					l154:
-						position, tokenIndex = position153, tokenIndex153
-						if buffer[position] != rune('W') {
-							goto l150
-						}
-						position++
-					}
-				l153:
-					{
-						position155, tokenIndex155 := position, tokenIndex
-						if buffer[position] != rune('o') {
-							goto l156
-						}
-						position++
-						goto l155
-					l156:
-						position, tokenIndex = position155, tokenIndex155
-						if buffer[position] != rune('O') {
-							goto l150
-						}
-						position++
-					}
-				l155:
-					{
-						position157, tokenIndex157 := position, tokenIndex
-						if buffer[position] != rune('r') {
-							goto l158
-						}
-						position++
-						goto l157
-					l158:
-						position, tokenIndex = position157, tokenIndex157
-						if buffer[position] != rune('R') {
-							goto l150
-						}
-						position++
-					}
-				l157:
-					{
-						position159, tokenIndex159 := position, tokenIndex
-						if buffer[position] != rune('d') {
-							goto l160
-						}
-						position++
-						goto l159
-					l160:
-						position, tokenIndex = position159, tokenIndex159
-						if buffer[position] != rune('D') {
-							goto l150
-						}
-						position++
-					}
-				l159:
-					goto l149
-				l150:
-					position, tokenIndex = position149, tokenIndex149
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l161
-					}
-					position++
-					{
-						position162, tokenIndex162 := position, tokenIndex
-						if buffer[position] != rune('w') {
-							goto l163
-						}
-						position++
 						goto l162
-					l163:
-						position, tokenIndex = position162, tokenIndex162
-						if buffer[position] != rune('W') {
-							goto l161
-						}
-						position++
-					}
-				l162:
-					{
-						position164, tokenIndex164 := position, tokenIndex
-						if buffer[position] != rune('o') {
-							goto l165
-						}
-						position++
-						goto l164
-					l165:
-						position, tokenIndex = position164, tokenIndex164
-						if buffer[position] != rune('O') {
-							goto l161
-						}
-						position++
-					}
-				l164:
-					{
-						position166, tokenIndex166 := position, tokenIndex
-						if buffer[position] != rune('r') {
-							goto l167
-						}
-						position++
-						goto l166
-					l167:
-						position, tokenIndex = position166, tokenIndex166
-						if buffer[position] != rune('R') {
-							goto l161
-						}
-						position++
-					}
-				l166:
-					{
-						position168, tokenIndex168 := position, tokenIndex
-						if buffer[position] != rune('d') {
-							goto l169
-						}
-						position++
-						goto l168
-					l169:
-						position, tokenIndex = position168, tokenIndex168
-						if buffer[position] != rune('D') {
-							goto l161
-						}
-						position++
-					}
-				l168:
-					goto l149
-				l161:
-					position, tokenIndex = position149, tokenIndex149
-					if buffer[position] != rune('.') {
-						goto l170
 					}
 					position++
 					{
-						position171, tokenIndex171 := position, tokenIndex
-						if buffer[position] != rune('h') {
-							goto l172
-						}
-						position++
-						goto l171
-					l172:
-						position, tokenIndex = position171, tokenIndex171
-						if buffer[position] != rune('H') {
-							goto l170
-						}
-						position++
-					}
-				l171:
-					{
-						position173, tokenIndex173 := position, tokenIndex
+						position163, tokenIndex163 := position, tokenIndex
 						if buffer[position] != rune('w') {
-							goto l174
+							goto l164
 						}
 						position++
-						goto l173
-					l174:
-						position, tokenIndex = position173, tokenIndex173
+						goto l163
+					l164:
+						position, tokenIndex = position163, tokenIndex163
 						if buffer[position] != rune('W') {
-							goto l170
+							goto l162
 						}
 						position++
 					}
-				l173:
+				l163:
 					{
-						position175, tokenIndex175 := position, tokenIndex
+						position165, tokenIndex165 := position, tokenIndex
 						if buffer[position] != rune('o') {
-							goto l176
+							goto l166
 						}
 						position++
-						goto l175
-					l176:
-						position, tokenIndex = position175, tokenIndex175
+						goto l165
+					l166:
+						position, tokenIndex = position165, tokenIndex165
 						if buffer[position] != rune('O') {
-							goto l170
+							goto l162
 						}
 						position++
 					}
-				l175:
+				l165:
 					{
-						position177, tokenIndex177 := position, tokenIndex
+						position167, tokenIndex167 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l178
+							goto l168
 						}
 						position++
-						goto l177
-					l178:
-						position, tokenIndex = position177, tokenIndex177
+						goto l167
+					l168:
+						position, tokenIndex = position167, tokenIndex167
 						if buffer[position] != rune('R') {
-							goto l170
+							goto l162
 						}
 						position++
 					}
-				l177:
+				l167:
 					{
-						position179, tokenIndex179 := position, tokenIndex
+						position169, tokenIndex169 := position, tokenIndex
 						if buffer[position] != rune('d') {
-							goto l180
-						}
-						position++
-						goto l179
-					l180:
-						position, tokenIndex = position179, tokenIndex179
-						if buffer[position] != rune('D') {
 							goto l170
 						}
 						position++
+						goto l169
+					l170:
+						position, tokenIndex = position169, tokenIndex169
+						if buffer[position] != rune('D') {
+							goto l162
+						}
+						position++
 					}
-				l179:
-					goto l149
-				l170:
-					position, tokenIndex = position149, tokenIndex149
+				l169:
+					goto l150
+				l162:
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l181
+						goto l171
 					}
 					position++
 					{
-						position182, tokenIndex182 := position, tokenIndex
-						if buffer[position] != rune('l') {
-							goto l183
+						position172, tokenIndex172 := position, tokenIndex
+						if buffer[position] != rune('h') {
+							goto l173
 						}
 						position++
-						goto l182
-					l183:
-						position, tokenIndex = position182, tokenIndex182
-						if buffer[position] != rune('L') {
-							goto l181
+						goto l172
+					l173:
+						position, tokenIndex = position172, tokenIndex172
+						if buffer[position] != rune('H') {
+							goto l171
 						}
 						position++
 					}
-				l182:
+				l172:
 					{
-						position184, tokenIndex184 := position, tokenIndex
+						position174, tokenIndex174 := position, tokenIndex
+						if buffer[position] != rune('w') {
+							goto l175
+						}
+						position++
+						goto l174
+					l175:
+						position, tokenIndex = position174, tokenIndex174
+						if buffer[position] != rune('W') {
+							goto l171
+						}
+						position++
+					}
+				l174:
+					{
+						position176, tokenIndex176 := position, tokenIndex
 						if buffer[position] != rune('o') {
-							goto l185
+							goto l177
 						}
 						position++
-						goto l184
-					l185:
-						position, tokenIndex = position184, tokenIndex184
+						goto l176
+					l177:
+						position, tokenIndex = position176, tokenIndex176
 						if buffer[position] != rune('O') {
-							goto l181
+							goto l171
 						}
 						position++
 					}
-				l184:
+				l176:
 					{
-						position186, tokenIndex186 := position, tokenIndex
+						position178, tokenIndex178 := position, tokenIndex
+						if buffer[position] != rune('r') {
+							goto l179
+						}
+						position++
+						goto l178
+					l179:
+						position, tokenIndex = position178, tokenIndex178
+						if buffer[position] != rune('R') {
+							goto l171
+						}
+						position++
+					}
+				l178:
+					{
+						position180, tokenIndex180 := position, tokenIndex
+						if buffer[position] != rune('d') {
+							goto l181
+						}
+						position++
+						goto l180
+					l181:
+						position, tokenIndex = position180, tokenIndex180
+						if buffer[position] != rune('D') {
+							goto l171
+						}
+						position++
+					}
+				l180:
+					goto l150
+				l171:
+					position, tokenIndex = position150, tokenIndex150
+					if buffer[position] != rune('.') {
+						goto l182
+					}
+					position++
+					{
+						position183, tokenIndex183 := position, tokenIndex
+						if buffer[position] != rune('l') {
+							goto l184
+						}
+						position++
+						goto l183
+					l184:
+						position, tokenIndex = position183, tokenIndex183
+						if buffer[position] != rune('L') {
+							goto l182
+						}
+						position++
+					}
+				l183:
+					{
+						position185, tokenIndex185 := position, tokenIndex
+						if buffer[position] != rune('o') {
+							goto l186
+						}
+						position++
+						goto l185
+					l186:
+						position, tokenIndex = position185, tokenIndex185
+						if buffer[position] != rune('O') {
+							goto l182
+						}
+						position++
+					}
+				l185:
+					{
+						position187, tokenIndex187 := position, tokenIndex
 						if buffer[position] != rune('n') {
-							goto l187
+							goto l188
 						}
 						position++
-						goto l186
-					l187:
-						position, tokenIndex = position186, tokenIndex186
+						goto l187
+					l188:
+						position, tokenIndex = position187, tokenIndex187
 						if buffer[position] != rune('N') {
-							goto l181
+							goto l182
 						}
 						position++
 					}
-				l186:
+				l187:
 					{
-						position188, tokenIndex188 := position, tokenIndex
+						position189, tokenIndex189 := position, tokenIndex
 						if buffer[position] != rune('g') {
-							goto l189
+							goto l190
 						}
 						position++
-						goto l188
-					l189:
-						position, tokenIndex = position188, tokenIndex188
+						goto l189
+					l190:
+						position, tokenIndex = position189, tokenIndex189
 						if buffer[position] != rune('G') {
-							goto l181
+							goto l182
 						}
 						position++
 					}
-				l188:
-					goto l149
-				l181:
-					position, tokenIndex = position149, tokenIndex149
+				l189:
+					goto l150
+				l182:
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l190
-					}
-					position++
-					{
-						position191, tokenIndex191 := position, tokenIndex
-						if buffer[position] != rune('s') {
-							goto l192
-						}
-						position++
 						goto l191
-					l192:
-						position, tokenIndex = position191, tokenIndex191
-						if buffer[position] != rune('S') {
-							goto l190
-						}
-						position++
-					}
-				l191:
-					{
-						position193, tokenIndex193 := position, tokenIndex
-						if buffer[position] != rune('e') {
-							goto l194
-						}
-						position++
-						goto l193
-					l194:
-						position, tokenIndex = position193, tokenIndex193
-						if buffer[position] != rune('E') {
-							goto l190
-						}
-						position++
-					}
-				l193:
-					{
-						position195, tokenIndex195 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l196
-						}
-						position++
-						goto l195
-					l196:
-						position, tokenIndex = position195, tokenIndex195
-						if buffer[position] != rune('T') {
-							goto l190
-						}
-						position++
-					}
-				l195:
-					goto l149
-				l190:
-					position, tokenIndex = position149, tokenIndex149
-					if buffer[position] != rune('.') {
-						goto l197
 					}
 					position++
 					{
-						position198, tokenIndex198 := position, tokenIndex
-						if buffer[position] != rune('b') {
-							goto l199
+						position192, tokenIndex192 := position, tokenIndex
+						if buffer[position] != rune('s') {
+							goto l193
 						}
 						position++
-						goto l198
-					l199:
-						position, tokenIndex = position198, tokenIndex198
-						if buffer[position] != rune('B') {
-							goto l197
+						goto l192
+					l193:
+						position, tokenIndex = position192, tokenIndex192
+						if buffer[position] != rune('S') {
+							goto l191
 						}
 						position++
 					}
-				l198:
+				l192:
 					{
-						position200, tokenIndex200 := position, tokenIndex
-						if buffer[position] != rune('y') {
-							goto l201
-						}
-						position++
-						goto l200
-					l201:
-						position, tokenIndex = position200, tokenIndex200
-						if buffer[position] != rune('Y') {
-							goto l197
-						}
-						position++
-					}
-				l200:
-					{
-						position202, tokenIndex202 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l203
-						}
-						position++
-						goto l202
-					l203:
-						position, tokenIndex = position202, tokenIndex202
-						if buffer[position] != rune('T') {
-							goto l197
-						}
-						position++
-					}
-				l202:
-					{
-						position204, tokenIndex204 := position, tokenIndex
+						position194, tokenIndex194 := position, tokenIndex
 						if buffer[position] != rune('e') {
-							goto l205
+							goto l195
 						}
 						position++
-						goto l204
-					l205:
-						position, tokenIndex = position204, tokenIndex204
+						goto l194
+					l195:
+						position, tokenIndex = position194, tokenIndex194
 						if buffer[position] != rune('E') {
-							goto l197
+							goto l191
 						}
 						position++
 					}
-				l204:
-					goto l149
-				l197:
-					position, tokenIndex = position149, tokenIndex149
+				l194:
+					{
+						position196, tokenIndex196 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l197
+						}
+						position++
+						goto l196
+					l197:
+						position, tokenIndex = position196, tokenIndex196
+						if buffer[position] != rune('T') {
+							goto l191
+						}
+						position++
+					}
+				l196:
+					goto l150
+				l191:
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l206
+						goto l198
+					}
+					position++
+					{
+						position199, tokenIndex199 := position, tokenIndex
+						if buffer[position] != rune('b') {
+							goto l200
+						}
+						position++
+						goto l199
+					l200:
+						position, tokenIndex = position199, tokenIndex199
+						if buffer[position] != rune('B') {
+							goto l198
+						}
+						position++
+					}
+				l199:
+					{
+						position201, tokenIndex201 := position, tokenIndex
+						if buffer[position] != rune('y') {
+							goto l202
+						}
+						position++
+						goto l201
+					l202:
+						position, tokenIndex = position201, tokenIndex201
+						if buffer[position] != rune('Y') {
+							goto l198
+						}
+						position++
+					}
+				l201:
+					{
+						position203, tokenIndex203 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l204
+						}
+						position++
+						goto l203
+					l204:
+						position, tokenIndex = position203, tokenIndex203
+						if buffer[position] != rune('T') {
+							goto l198
+						}
+						position++
+					}
+				l203:
+					{
+						position205, tokenIndex205 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l206
+						}
+						position++
+						goto l205
+					l206:
+						position, tokenIndex = position205, tokenIndex205
+						if buffer[position] != rune('E') {
+							goto l198
+						}
+						position++
+					}
+				l205:
+					goto l150
+				l198:
+					position, tokenIndex = position150, tokenIndex150
+					if buffer[position] != rune('.') {
+						goto l207
 					}
 					position++
 					if buffer[position] != rune('8') {
-						goto l206
+						goto l207
 					}
 					position++
 					{
-						position207, tokenIndex207 := position, tokenIndex
+						position208, tokenIndex208 := position, tokenIndex
 						if buffer[position] != rune('b') {
-							goto l208
+							goto l209
 						}
 						position++
-						goto l207
-					l208:
-						position, tokenIndex = position207, tokenIndex207
+						goto l208
+					l209:
+						position, tokenIndex = position208, tokenIndex208
 						if buffer[position] != rune('B') {
-							goto l206
+							goto l207
 						}
 						position++
 					}
-				l207:
+				l208:
 					{
-						position209, tokenIndex209 := position, tokenIndex
+						position210, tokenIndex210 := position, tokenIndex
 						if buffer[position] != rune('y') {
-							goto l210
+							goto l211
 						}
 						position++
-						goto l209
-					l210:
-						position, tokenIndex = position209, tokenIndex209
+						goto l210
+					l211:
+						position, tokenIndex = position210, tokenIndex210
 						if buffer[position] != rune('Y') {
-							goto l206
+							goto l207
 						}
 						position++
 					}
-				l209:
+				l210:
 					{
-						position211, tokenIndex211 := position, tokenIndex
+						position212, tokenIndex212 := position, tokenIndex
 						if buffer[position] != rune('t') {
-							goto l212
+							goto l213
 						}
 						position++
-						goto l211
-					l212:
-						position, tokenIndex = position211, tokenIndex211
+						goto l212
+					l213:
+						position, tokenIndex = position212, tokenIndex212
 						if buffer[position] != rune('T') {
-							goto l206
+							goto l207
 						}
 						position++
 					}
-				l211:
+				l212:
 					{
-						position213, tokenIndex213 := position, tokenIndex
+						position214, tokenIndex214 := position, tokenIndex
 						if buffer[position] != rune('e') {
-							goto l214
+							goto l215
 						}
 						position++
-						goto l213
-					l214:
-						position, tokenIndex = position213, tokenIndex213
+						goto l214
+					l215:
+						position, tokenIndex = position214, tokenIndex214
 						if buffer[position] != rune('E') {
-							goto l206
+							goto l207
 						}
 						position++
 					}
-				l213:
-					goto l149
-				l206:
-					position, tokenIndex = position149, tokenIndex149
+				l214:
+					goto l150
+				l207:
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l215
+						goto l216
 					}
 					position++
 					if buffer[position] != rune('4') {
-						goto l215
-					}
-					position++
-					{
-						position216, tokenIndex216 := position, tokenIndex
-						if buffer[position] != rune('b') {
-							goto l217
-						}
-						position++
 						goto l216
-					l217:
-						position, tokenIndex = position216, tokenIndex216
+					}
+					position++
+					{
+						position217, tokenIndex217 := position, tokenIndex
+						if buffer[position] != rune('b') {
+							goto l218
+						}
+						position++
+						goto l217
+					l218:
+						position, tokenIndex = position217, tokenIndex217
 						if buffer[position] != rune('B') {
-							goto l215
+							goto l216
 						}
 						position++
 					}
+				l217:
+					{
+						position219, tokenIndex219 := position, tokenIndex
+						if buffer[position] != rune('y') {
+							goto l220
+						}
+						position++
+						goto l219
+					l220:
+						position, tokenIndex = position219, tokenIndex219
+						if buffer[position] != rune('Y') {
+							goto l216
+						}
+						position++
+					}
+				l219:
+					{
+						position221, tokenIndex221 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l222
+						}
+						position++
+						goto l221
+					l222:
+						position, tokenIndex = position221, tokenIndex221
+						if buffer[position] != rune('T') {
+							goto l216
+						}
+						position++
+					}
+				l221:
+					{
+						position223, tokenIndex223 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l224
+						}
+						position++
+						goto l223
+					l224:
+						position, tokenIndex = position223, tokenIndex223
+						if buffer[position] != rune('E') {
+							goto l216
+						}
+						position++
+					}
+				l223:
+					goto l150
 				l216:
-					{
-						position218, tokenIndex218 := position, tokenIndex
-						if buffer[position] != rune('y') {
-							goto l219
-						}
-						position++
-						goto l218
-					l219:
-						position, tokenIndex = position218, tokenIndex218
-						if buffer[position] != rune('Y') {
-							goto l215
-						}
-						position++
-					}
-				l218:
-					{
-						position220, tokenIndex220 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l221
-						}
-						position++
-						goto l220
-					l221:
-						position, tokenIndex = position220, tokenIndex220
-						if buffer[position] != rune('T') {
-							goto l215
-						}
-						position++
-					}
-				l220:
-					{
-						position222, tokenIndex222 := position, tokenIndex
-						if buffer[position] != rune('e') {
-							goto l223
-						}
-						position++
-						goto l222
-					l223:
-						position, tokenIndex = position222, tokenIndex222
-						if buffer[position] != rune('E') {
-							goto l215
-						}
-						position++
-					}
-				l222:
-					goto l149
-				l215:
-					position, tokenIndex = position149, tokenIndex149
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l224
-					}
-					position++
-					{
-						position225, tokenIndex225 := position, tokenIndex
-						if buffer[position] != rune('q') {
-							goto l226
-						}
-						position++
 						goto l225
-					l226:
-						position, tokenIndex = position225, tokenIndex225
+					}
+					position++
+					{
+						position226, tokenIndex226 := position, tokenIndex
+						if buffer[position] != rune('q') {
+							goto l227
+						}
+						position++
+						goto l226
+					l227:
+						position, tokenIndex = position226, tokenIndex226
 						if buffer[position] != rune('Q') {
-							goto l224
+							goto l225
 						}
 						position++
 					}
-				l225:
+				l226:
 					{
-						position227, tokenIndex227 := position, tokenIndex
+						position228, tokenIndex228 := position, tokenIndex
 						if buffer[position] != rune('u') {
-							goto l228
+							goto l229
 						}
 						position++
-						goto l227
-					l228:
-						position, tokenIndex = position227, tokenIndex227
+						goto l228
+					l229:
+						position, tokenIndex = position228, tokenIndex228
 						if buffer[position] != rune('U') {
-							goto l224
+							goto l225
 						}
 						position++
 					}
-				l227:
+				l228:
 					{
-						position229, tokenIndex229 := position, tokenIndex
+						position230, tokenIndex230 := position, tokenIndex
 						if buffer[position] != rune('a') {
-							goto l230
+							goto l231
 						}
 						position++
-						goto l229
-					l230:
-						position, tokenIndex = position229, tokenIndex229
+						goto l230
+					l231:
+						position, tokenIndex = position230, tokenIndex230
 						if buffer[position] != rune('A') {
-							goto l224
+							goto l225
 						}
 						position++
 					}
-				l229:
+				l230:
 					{
-						position231, tokenIndex231 := position, tokenIndex
+						position232, tokenIndex232 := position, tokenIndex
 						if buffer[position] != rune('d') {
-							goto l232
+							goto l233
 						}
 						position++
-						goto l231
-					l232:
-						position, tokenIndex = position231, tokenIndex231
+						goto l232
+					l233:
+						position, tokenIndex = position232, tokenIndex232
 						if buffer[position] != rune('D') {
-							goto l224
+							goto l225
 						}
 						position++
 					}
-				l231:
-					goto l149
-				l224:
-					position, tokenIndex = position149, tokenIndex149
+				l232:
+					goto l150
+				l225:
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l233
-					}
-					position++
-					{
-						position234, tokenIndex234 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l235
-						}
-						position++
 						goto l234
-					l235:
-						position, tokenIndex = position234, tokenIndex234
+					}
+					position++
+					{
+						position235, tokenIndex235 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l236
+						}
+						position++
+						goto l235
+					l236:
+						position, tokenIndex = position235, tokenIndex235
 						if buffer[position] != rune('T') {
-							goto l233
+							goto l234
 						}
 						position++
 					}
+				l235:
+					{
+						position237, tokenIndex237 := position, tokenIndex
+						if buffer[position] != rune('c') {
+							goto l238
+						}
+						position++
+						goto l237
+					l238:
+						position, tokenIndex = position237, tokenIndex237
+						if buffer[position] != rune('C') {
+							goto l234
+						}
+						position++
+					}
+				l237:
+					goto l150
 				l234:
-					{
-						position236, tokenIndex236 := position, tokenIndex
-						if buffer[position] != rune('c') {
-							goto l237
-						}
-						position++
-						goto l236
-					l237:
-						position, tokenIndex = position236, tokenIndex236
-						if buffer[position] != rune('C') {
-							goto l233
-						}
-						position++
-					}
-				l236:
-					goto l149
-				l233:
-					position, tokenIndex = position149, tokenIndex149
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l238
-					}
-					position++
-					{
-						position239, tokenIndex239 := position, tokenIndex
-						if buffer[position] != rune('l') {
-							goto l240
-						}
-						position++
 						goto l239
-					l240:
-						position, tokenIndex = position239, tokenIndex239
+					}
+					position++
+					{
+						position240, tokenIndex240 := position, tokenIndex
+						if buffer[position] != rune('l') {
+							goto l241
+						}
+						position++
+						goto l240
+					l241:
+						position, tokenIndex = position240, tokenIndex240
 						if buffer[position] != rune('L') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l239:
+				l240:
 					{
-						position241, tokenIndex241 := position, tokenIndex
+						position242, tokenIndex242 := position, tokenIndex
 						if buffer[position] != rune('o') {
-							goto l242
+							goto l243
 						}
 						position++
-						goto l241
-					l242:
-						position, tokenIndex = position241, tokenIndex241
+						goto l242
+					l243:
+						position, tokenIndex = position242, tokenIndex242
 						if buffer[position] != rune('O') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l241:
+				l242:
 					{
-						position243, tokenIndex243 := position, tokenIndex
+						position244, tokenIndex244 := position, tokenIndex
 						if buffer[position] != rune('c') {
-							goto l244
+							goto l245
 						}
 						position++
-						goto l243
-					l244:
-						position, tokenIndex = position243, tokenIndex243
+						goto l244
+					l245:
+						position, tokenIndex = position244, tokenIndex244
 						if buffer[position] != rune('C') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l243:
+				l244:
 					{
-						position245, tokenIndex245 := position, tokenIndex
+						position246, tokenIndex246 := position, tokenIndex
 						if buffer[position] != rune('a') {
-							goto l246
+							goto l247
 						}
 						position++
-						goto l245
-					l246:
-						position, tokenIndex = position245, tokenIndex245
+						goto l246
+					l247:
+						position, tokenIndex = position246, tokenIndex246
 						if buffer[position] != rune('A') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l245:
+				l246:
 					{
-						position247, tokenIndex247 := position, tokenIndex
+						position248, tokenIndex248 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l248
+							goto l249
 						}
 						position++
-						goto l247
-					l248:
-						position, tokenIndex = position247, tokenIndex247
+						goto l248
+					l249:
+						position, tokenIndex = position248, tokenIndex248
 						if buffer[position] != rune('L') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l247:
+				l248:
 					{
-						position249, tokenIndex249 := position, tokenIndex
+						position250, tokenIndex250 := position, tokenIndex
 						if buffer[position] != rune('e') {
-							goto l250
+							goto l251
 						}
 						position++
-						goto l249
-					l250:
-						position, tokenIndex = position249, tokenIndex249
+						goto l250
+					l251:
+						position, tokenIndex = position250, tokenIndex250
 						if buffer[position] != rune('E') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l249:
+				l250:
 					{
-						position251, tokenIndex251 := position, tokenIndex
+						position252, tokenIndex252 := position, tokenIndex
 						if buffer[position] != rune('n') {
-							goto l252
+							goto l253
 						}
 						position++
-						goto l251
-					l252:
-						position, tokenIndex = position251, tokenIndex251
+						goto l252
+					l253:
+						position, tokenIndex = position252, tokenIndex252
 						if buffer[position] != rune('N') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l251:
+				l252:
 					{
-						position253, tokenIndex253 := position, tokenIndex
+						position254, tokenIndex254 := position, tokenIndex
 						if buffer[position] != rune('t') {
-							goto l254
+							goto l255
 						}
 						position++
-						goto l253
-					l254:
-						position, tokenIndex = position253, tokenIndex253
+						goto l254
+					l255:
+						position, tokenIndex = position254, tokenIndex254
 						if buffer[position] != rune('T') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l253:
+				l254:
 					{
-						position255, tokenIndex255 := position, tokenIndex
+						position256, tokenIndex256 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l256
+							goto l257
 						}
 						position++
-						goto l255
-					l256:
-						position, tokenIndex = position255, tokenIndex255
+						goto l256
+					l257:
+						position, tokenIndex = position256, tokenIndex256
 						if buffer[position] != rune('R') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l255:
+				l256:
 					{
-						position257, tokenIndex257 := position, tokenIndex
+						position258, tokenIndex258 := position, tokenIndex
 						if buffer[position] != rune('y') {
-							goto l258
+							goto l259
 						}
 						position++
-						goto l257
-					l258:
-						position, tokenIndex = position257, tokenIndex257
+						goto l258
+					l259:
+						position, tokenIndex = position258, tokenIndex258
 						if buffer[position] != rune('Y') {
-							goto l238
+							goto l239
 						}
 						position++
 					}
-				l257:
-					goto l149
-				l238:
-					position, tokenIndex = position149, tokenIndex149
+				l258:
+					goto l150
+				l239:
+					position, tokenIndex = position150, tokenIndex150
 					if buffer[position] != rune('.') {
-						goto l259
-					}
-					position++
-					{
-						position260, tokenIndex260 := position, tokenIndex
-						if buffer[position] != rune('s') {
-							goto l261
-						}
-						position++
 						goto l260
-					l261:
-						position, tokenIndex = position260, tokenIndex260
-						if buffer[position] != rune('S') {
-							goto l259
-						}
-						position++
-					}
-				l260:
-					{
-						position262, tokenIndex262 := position, tokenIndex
-						if buffer[position] != rune('i') {
-							goto l263
-						}
-						position++
-						goto l262
-					l263:
-						position, tokenIndex = position262, tokenIndex262
-						if buffer[position] != rune('I') {
-							goto l259
-						}
-						position++
-					}
-				l262:
-					{
-						position264, tokenIndex264 := position, tokenIndex
-						if buffer[position] != rune('z') {
-							goto l265
-						}
-						position++
-						goto l264
-					l265:
-						position, tokenIndex = position264, tokenIndex264
-						if buffer[position] != rune('Z') {
-							goto l259
-						}
-						position++
-					}
-				l264:
-					{
-						position266, tokenIndex266 := position, tokenIndex
-						if buffer[position] != rune('e') {
-							goto l267
-						}
-						position++
-						goto l266
-					l267:
-						position, tokenIndex = position266, tokenIndex266
-						if buffer[position] != rune('E') {
-							goto l259
-						}
-						position++
-					}
-				l266:
-					goto l149
-				l259:
-					position, tokenIndex = position149, tokenIndex149
-					if buffer[position] != rune('.') {
-						goto l268
 					}
 					position++
 					{
-						position269, tokenIndex269 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l270
-						}
-						position++
-						goto l269
-					l270:
-						position, tokenIndex = position269, tokenIndex269
-						if buffer[position] != rune('T') {
-							goto l268
-						}
-						position++
-					}
-				l269:
-					{
-						position271, tokenIndex271 := position, tokenIndex
-						if buffer[position] != rune('y') {
-							goto l272
-						}
-						position++
-						goto l271
-					l272:
-						position, tokenIndex = position271, tokenIndex271
-						if buffer[position] != rune('Y') {
-							goto l268
-						}
-						position++
-					}
-				l271:
-					{
-						position273, tokenIndex273 := position, tokenIndex
-						if buffer[position] != rune('p') {
-							goto l274
-						}
-						position++
-						goto l273
-					l274:
-						position, tokenIndex = position273, tokenIndex273
-						if buffer[position] != rune('P') {
-							goto l268
-						}
-						position++
-					}
-				l273:
-					{
-						position275, tokenIndex275 := position, tokenIndex
-						if buffer[position] != rune('e') {
-							goto l276
-						}
-						position++
-						goto l275
-					l276:
-						position, tokenIndex = position275, tokenIndex275
-						if buffer[position] != rune('E') {
-							goto l268
-						}
-						position++
-					}
-				l275:
-					goto l149
-				l268:
-					position, tokenIndex = position149, tokenIndex149
-					if buffer[position] != rune('.') {
-						goto l277
-					}
-					position++
-					{
-						position278, tokenIndex278 := position, tokenIndex
-						if buffer[position] != rune('u') {
-							goto l279
-						}
-						position++
-						goto l278
-					l279:
-						position, tokenIndex = position278, tokenIndex278
-						if buffer[position] != rune('U') {
-							goto l277
-						}
-						position++
-					}
-				l278:
-					{
-						position280, tokenIndex280 := position, tokenIndex
-						if buffer[position] != rune('l') {
-							goto l281
-						}
-						position++
-						goto l280
-					l281:
-						position, tokenIndex = position280, tokenIndex280
-						if buffer[position] != rune('L') {
-							goto l277
-						}
-						position++
-					}
-				l280:
-					{
-						position282, tokenIndex282 := position, tokenIndex
-						if buffer[position] != rune('e') {
-							goto l283
-						}
-						position++
-						goto l282
-					l283:
-						position, tokenIndex = position282, tokenIndex282
-						if buffer[position] != rune('E') {
-							goto l277
-						}
-						position++
-					}
-				l282:
-					{
-						position284, tokenIndex284 := position, tokenIndex
-						if buffer[position] != rune('b') {
-							goto l285
-						}
-						position++
-						goto l284
-					l285:
-						position, tokenIndex = position284, tokenIndex284
-						if buffer[position] != rune('B') {
-							goto l277
-						}
-						position++
-					}
-				l284:
-					if buffer[position] != rune('1') {
-						goto l277
-					}
-					position++
-					if buffer[position] != rune('2') {
-						goto l277
-					}
-					position++
-					if buffer[position] != rune('8') {
-						goto l277
-					}
-					position++
-					goto l149
-				l277:
-					position, tokenIndex = position149, tokenIndex149
-					if buffer[position] != rune('.') {
-						goto l147
-					}
-					position++
-					{
-						position286, tokenIndex286 := position, tokenIndex
+						position261, tokenIndex261 := position, tokenIndex
 						if buffer[position] != rune('s') {
-							goto l287
+							goto l262
 						}
 						position++
-						goto l286
-					l287:
-						position, tokenIndex = position286, tokenIndex286
+						goto l261
+					l262:
+						position, tokenIndex = position261, tokenIndex261
 						if buffer[position] != rune('S') {
-							goto l147
+							goto l260
 						}
 						position++
 					}
-				l286:
+				l261:
 					{
-						position288, tokenIndex288 := position, tokenIndex
-						if buffer[position] != rune('l') {
-							goto l289
+						position263, tokenIndex263 := position, tokenIndex
+						if buffer[position] != rune('i') {
+							goto l264
 						}
 						position++
-						goto l288
-					l289:
-						position, tokenIndex = position288, tokenIndex288
-						if buffer[position] != rune('L') {
-							goto l147
+						goto l263
+					l264:
+						position, tokenIndex = position263, tokenIndex263
+						if buffer[position] != rune('I') {
+							goto l260
 						}
 						position++
 					}
-				l288:
+				l263:
 					{
-						position290, tokenIndex290 := position, tokenIndex
+						position265, tokenIndex265 := position, tokenIndex
+						if buffer[position] != rune('z') {
+							goto l266
+						}
+						position++
+						goto l265
+					l266:
+						position, tokenIndex = position265, tokenIndex265
+						if buffer[position] != rune('Z') {
+							goto l260
+						}
+						position++
+					}
+				l265:
+					{
+						position267, tokenIndex267 := position, tokenIndex
 						if buffer[position] != rune('e') {
-							goto l291
+							goto l268
 						}
 						position++
-						goto l290
-					l291:
-						position, tokenIndex = position290, tokenIndex290
+						goto l267
+					l268:
+						position, tokenIndex = position267, tokenIndex267
 						if buffer[position] != rune('E') {
-							goto l147
+							goto l260
 						}
 						position++
 					}
-				l290:
+				l267:
+					goto l150
+				l260:
+					position, tokenIndex = position150, tokenIndex150
+					if buffer[position] != rune('.') {
+						goto l269
+					}
+					position++
 					{
-						position292, tokenIndex292 := position, tokenIndex
-						if buffer[position] != rune('b') {
-							goto l293
+						position270, tokenIndex270 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l271
 						}
 						position++
-						goto l292
-					l293:
-						position, tokenIndex = position292, tokenIndex292
-						if buffer[position] != rune('B') {
-							goto l147
+						goto l270
+					l271:
+						position, tokenIndex = position270, tokenIndex270
+						if buffer[position] != rune('T') {
+							goto l269
 						}
 						position++
 					}
-				l292:
+				l270:
+					{
+						position272, tokenIndex272 := position, tokenIndex
+						if buffer[position] != rune('y') {
+							goto l273
+						}
+						position++
+						goto l272
+					l273:
+						position, tokenIndex = position272, tokenIndex272
+						if buffer[position] != rune('Y') {
+							goto l269
+						}
+						position++
+					}
+				l272:
+					{
+						position274, tokenIndex274 := position, tokenIndex
+						if buffer[position] != rune('p') {
+							goto l275
+						}
+						position++
+						goto l274
+					l275:
+						position, tokenIndex = position274, tokenIndex274
+						if buffer[position] != rune('P') {
+							goto l269
+						}
+						position++
+					}
+				l274:
+					{
+						position276, tokenIndex276 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l277
+						}
+						position++
+						goto l276
+					l277:
+						position, tokenIndex = position276, tokenIndex276
+						if buffer[position] != rune('E') {
+							goto l269
+						}
+						position++
+					}
+				l276:
+					goto l150
+				l269:
+					position, tokenIndex = position150, tokenIndex150
+					if buffer[position] != rune('.') {
+						goto l278
+					}
+					position++
+					{
+						position279, tokenIndex279 := position, tokenIndex
+						if buffer[position] != rune('u') {
+							goto l280
+						}
+						position++
+						goto l279
+					l280:
+						position, tokenIndex = position279, tokenIndex279
+						if buffer[position] != rune('U') {
+							goto l278
+						}
+						position++
+					}
+				l279:
+					{
+						position281, tokenIndex281 := position, tokenIndex
+						if buffer[position] != rune('l') {
+							goto l282
+						}
+						position++
+						goto l281
+					l282:
+						position, tokenIndex = position281, tokenIndex281
+						if buffer[position] != rune('L') {
+							goto l278
+						}
+						position++
+					}
+				l281:
+					{
+						position283, tokenIndex283 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l284
+						}
+						position++
+						goto l283
+					l284:
+						position, tokenIndex = position283, tokenIndex283
+						if buffer[position] != rune('E') {
+							goto l278
+						}
+						position++
+					}
+				l283:
+					{
+						position285, tokenIndex285 := position, tokenIndex
+						if buffer[position] != rune('b') {
+							goto l286
+						}
+						position++
+						goto l285
+					l286:
+						position, tokenIndex = position285, tokenIndex285
+						if buffer[position] != rune('B') {
+							goto l278
+						}
+						position++
+					}
+				l285:
 					if buffer[position] != rune('1') {
-						goto l147
+						goto l278
 					}
 					position++
 					if buffer[position] != rune('2') {
-						goto l147
+						goto l278
 					}
 					position++
 					if buffer[position] != rune('8') {
-						goto l147
+						goto l278
+					}
+					position++
+					goto l150
+				l278:
+					position, tokenIndex = position150, tokenIndex150
+					if buffer[position] != rune('.') {
+						goto l148
+					}
+					position++
+					{
+						position287, tokenIndex287 := position, tokenIndex
+						if buffer[position] != rune('s') {
+							goto l288
+						}
+						position++
+						goto l287
+					l288:
+						position, tokenIndex = position287, tokenIndex287
+						if buffer[position] != rune('S') {
+							goto l148
+						}
+						position++
+					}
+				l287:
+					{
+						position289, tokenIndex289 := position, tokenIndex
+						if buffer[position] != rune('l') {
+							goto l290
+						}
+						position++
+						goto l289
+					l290:
+						position, tokenIndex = position289, tokenIndex289
+						if buffer[position] != rune('L') {
+							goto l148
+						}
+						position++
+					}
+				l289:
+					{
+						position291, tokenIndex291 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l292
+						}
+						position++
+						goto l291
+					l292:
+						position, tokenIndex = position291, tokenIndex291
+						if buffer[position] != rune('E') {
+							goto l148
+						}
+						position++
+					}
+				l291:
+					{
+						position293, tokenIndex293 := position, tokenIndex
+						if buffer[position] != rune('b') {
+							goto l294
+						}
+						position++
+						goto l293
+					l294:
+						position, tokenIndex = position293, tokenIndex293
+						if buffer[position] != rune('B') {
+							goto l148
+						}
+						position++
+					}
+				l293:
+					if buffer[position] != rune('1') {
+						goto l148
+					}
+					position++
+					if buffer[position] != rune('2') {
+						goto l148
+					}
+					position++
+					if buffer[position] != rune('8') {
+						goto l148
 					}
 					position++
 				}
-			l149:
-				add(ruleLabelContainingDirectiveName, position148)
+			l150:
+				add(ruleLabelContainingDirectiveName, position149)
 			}
 			return true
-		l147:
-			position, tokenIndex = position147, tokenIndex147
+		l148:
+			position, tokenIndex = position148, tokenIndex148
 			return false
 		},
 		/* 14 SymbolArgs <- <(SymbolArg (WS? ',' WS? SymbolArg)*)> */
 		func() bool {
-			position294, tokenIndex294 := position, tokenIndex
+			position295, tokenIndex295 := position, tokenIndex
 			{
-				position295 := position
+				position296 := position
 				if !_rules[ruleSymbolArg]() {
-					goto l294
+					goto l295
 				}
-			l296:
+			l297:
 				{
-					position297, tokenIndex297 := position, tokenIndex
+					position298, tokenIndex298 := position, tokenIndex
 					{
-						position298, tokenIndex298 := position, tokenIndex
+						position299, tokenIndex299 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l298
+							goto l299
 						}
-						goto l299
-					l298:
-						position, tokenIndex = position298, tokenIndex298
+						goto l300
+					l299:
+						position, tokenIndex = position299, tokenIndex299
 					}
-				l299:
+				l300:
 					if buffer[position] != rune(',') {
-						goto l297
+						goto l298
 					}
 					position++
 					{
-						position300, tokenIndex300 := position, tokenIndex
+						position301, tokenIndex301 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l300
+							goto l301
 						}
-						goto l301
-					l300:
-						position, tokenIndex = position300, tokenIndex300
+						goto l302
+					l301:
+						position, tokenIndex = position301, tokenIndex301
 					}
-				l301:
+				l302:
 					if !_rules[ruleSymbolArg]() {
-						goto l297
+						goto l298
 					}
-					goto l296
-				l297:
-					position, tokenIndex = position297, tokenIndex297
+					goto l297
+				l298:
+					position, tokenIndex = position298, tokenIndex298
 				}
-				add(ruleSymbolArgs, position295)
+				add(ruleSymbolArgs, position296)
 			}
 			return true
-		l294:
-			position, tokenIndex = position294, tokenIndex294
+		l295:
+			position, tokenIndex = position295, tokenIndex295
 			return false
 		},
 		/* 15 SymbolArg <- <SymbolExpr> */
 		func() bool {
-			position302, tokenIndex302 := position, tokenIndex
+			position303, tokenIndex303 := position, tokenIndex
 			{
-				position303 := position
+				position304 := position
 				if !_rules[ruleSymbolExpr]() {
-					goto l302
+					goto l303
 				}
-				add(ruleSymbolArg, position303)
+				add(ruleSymbolArg, position304)
 			}
 			return true
-		l302:
-			position, tokenIndex = position302, tokenIndex302
+		l303:
+			position, tokenIndex = position303, tokenIndex303
 			return false
 		},
 		/* 16 SymbolExpr <- <(SymbolAtom (WS? SymbolOperator WS? SymbolExpr)?)> */
 		func() bool {
-			position304, tokenIndex304 := position, tokenIndex
+			position305, tokenIndex305 := position, tokenIndex
 			{
-				position305 := position
+				position306 := position
 				if !_rules[ruleSymbolAtom]() {
-					goto l304
+					goto l305
 				}
 				{
-					position306, tokenIndex306 := position, tokenIndex
+					position307, tokenIndex307 := position, tokenIndex
 					{
-						position308, tokenIndex308 := position, tokenIndex
+						position309, tokenIndex309 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l308
+							goto l309
 						}
-						goto l309
-					l308:
-						position, tokenIndex = position308, tokenIndex308
+						goto l310
+					l309:
+						position, tokenIndex = position309, tokenIndex309
 					}
-				l309:
+				l310:
 					if !_rules[ruleSymbolOperator]() {
-						goto l306
+						goto l307
 					}
 					{
-						position310, tokenIndex310 := position, tokenIndex
+						position311, tokenIndex311 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l310
+							goto l311
 						}
-						goto l311
-					l310:
-						position, tokenIndex = position310, tokenIndex310
+						goto l312
+					l311:
+						position, tokenIndex = position311, tokenIndex311
 					}
-				l311:
+				l312:
 					if !_rules[ruleSymbolExpr]() {
-						goto l306
+						goto l307
 					}
-					goto l307
-				l306:
-					position, tokenIndex = position306, tokenIndex306
+					goto l308
+				l307:
+					position, tokenIndex = position307, tokenIndex307
 				}
-			l307:
-				add(ruleSymbolExpr, position305)
+			l308:
+				add(ruleSymbolExpr, position306)
 			}
 			return true
-		l304:
-			position, tokenIndex = position304, tokenIndex304
+		l305:
+			position, tokenIndex = position305, tokenIndex305
 			return false
 		},
 		/* 17 SymbolAtom <- <(LocalLabelRef / Offset / SymbolType / (LocalSymbol TCMarker?) / (SymbolName Offset) / (SymbolName TCMarker?) / Dot / (OpenParen WS? SymbolExpr WS? CloseParen))> */
 		func() bool {
-			position312, tokenIndex312 := position, tokenIndex
+			position313, tokenIndex313 := position, tokenIndex
 			{
-				position313 := position
+				position314 := position
 				{
-					position314, tokenIndex314 := position, tokenIndex
+					position315, tokenIndex315 := position, tokenIndex
 					if !_rules[ruleLocalLabelRef]() {
-						goto l315
-					}
-					goto l314
-				l315:
-					position, tokenIndex = position314, tokenIndex314
-					if !_rules[ruleOffset]() {
 						goto l316
 					}
-					goto l314
+					goto l315
 				l316:
-					position, tokenIndex = position314, tokenIndex314
-					if !_rules[ruleSymbolType]() {
+					position, tokenIndex = position315, tokenIndex315
+					if !_rules[ruleOffset]() {
 						goto l317
 					}
-					goto l314
+					goto l315
 				l317:
-					position, tokenIndex = position314, tokenIndex314
-					if !_rules[ruleLocalSymbol]() {
+					position, tokenIndex = position315, tokenIndex315
+					if !_rules[ruleSymbolType]() {
 						goto l318
 					}
-					{
-						position319, tokenIndex319 := position, tokenIndex
-						if !_rules[ruleTCMarker]() {
-							goto l319
-						}
-						goto l320
-					l319:
-						position, tokenIndex = position319, tokenIndex319
-					}
-				l320:
-					goto l314
+					goto l315
 				l318:
-					position, tokenIndex = position314, tokenIndex314
-					if !_rules[ruleSymbolName]() {
-						goto l321
+					position, tokenIndex = position315, tokenIndex315
+					if !_rules[ruleLocalSymbol]() {
+						goto l319
 					}
-					if !_rules[ruleOffset]() {
+					{
+						position320, tokenIndex320 := position, tokenIndex
+						if !_rules[ruleTCMarker]() {
+							goto l320
+						}
 						goto l321
+					l320:
+						position, tokenIndex = position320, tokenIndex320
 					}
-					goto l314
 				l321:
-					position, tokenIndex = position314, tokenIndex314
+					goto l315
+				l319:
+					position, tokenIndex = position315, tokenIndex315
 					if !_rules[ruleSymbolName]() {
 						goto l322
 					}
-					{
-						position323, tokenIndex323 := position, tokenIndex
-						if !_rules[ruleTCMarker]() {
-							goto l323
-						}
-						goto l324
-					l323:
-						position, tokenIndex = position323, tokenIndex323
+					if !_rules[ruleOffset]() {
+						goto l322
 					}
-				l324:
-					goto l314
+					goto l315
 				l322:
-					position, tokenIndex = position314, tokenIndex314
-					if !_rules[ruleDot]() {
+					position, tokenIndex = position315, tokenIndex315
+					if !_rules[ruleSymbolName]() {
+						goto l323
+					}
+					{
+						position324, tokenIndex324 := position, tokenIndex
+						if !_rules[ruleTCMarker]() {
+							goto l324
+						}
 						goto l325
+					l324:
+						position, tokenIndex = position324, tokenIndex324
 					}
-					goto l314
 				l325:
-					position, tokenIndex = position314, tokenIndex314
+					goto l315
+				l323:
+					position, tokenIndex = position315, tokenIndex315
+					if !_rules[ruleDot]() {
+						goto l326
+					}
+					goto l315
+				l326:
+					position, tokenIndex = position315, tokenIndex315
 					if !_rules[ruleOpenParen]() {
-						goto l312
+						goto l313
 					}
 					{
-						position326, tokenIndex326 := position, tokenIndex
+						position327, tokenIndex327 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l326
+							goto l327
 						}
-						goto l327
-					l326:
-						position, tokenIndex = position326, tokenIndex326
+						goto l328
+					l327:
+						position, tokenIndex = position327, tokenIndex327
 					}
-				l327:
+				l328:
 					if !_rules[ruleSymbolExpr]() {
-						goto l312
+						goto l313
 					}
 					{
-						position328, tokenIndex328 := position, tokenIndex
+						position329, tokenIndex329 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l328
+							goto l329
 						}
-						goto l329
-					l328:
-						position, tokenIndex = position328, tokenIndex328
+						goto l330
+					l329:
+						position, tokenIndex = position329, tokenIndex329
 					}
-				l329:
+				l330:
 					if !_rules[ruleCloseParen]() {
-						goto l312
+						goto l313
 					}
 				}
-			l314:
-				add(ruleSymbolAtom, position313)
+			l315:
+				add(ruleSymbolAtom, position314)
 			}
 			return true
-		l312:
-			position, tokenIndex = position312, tokenIndex312
+		l313:
+			position, tokenIndex = position313, tokenIndex313
 			return false
 		},
 		/* 18 SymbolOperator <- <('+' / '-' / '|' / ('<' '<') / ('>' '>'))> */
 		func() bool {
-			position330, tokenIndex330 := position, tokenIndex
+			position331, tokenIndex331 := position, tokenIndex
 			{
-				position331 := position
+				position332 := position
 				{
-					position332, tokenIndex332 := position, tokenIndex
+					position333, tokenIndex333 := position, tokenIndex
 					if buffer[position] != rune('+') {
-						goto l333
-					}
-					position++
-					goto l332
-				l333:
-					position, tokenIndex = position332, tokenIndex332
-					if buffer[position] != rune('-') {
 						goto l334
 					}
 					position++
-					goto l332
+					goto l333
 				l334:
-					position, tokenIndex = position332, tokenIndex332
-					if buffer[position] != rune('|') {
+					position, tokenIndex = position333, tokenIndex333
+					if buffer[position] != rune('-') {
 						goto l335
 					}
 					position++
-					goto l332
+					goto l333
 				l335:
-					position, tokenIndex = position332, tokenIndex332
-					if buffer[position] != rune('<') {
+					position, tokenIndex = position333, tokenIndex333
+					if buffer[position] != rune('|') {
 						goto l336
 					}
 					position++
-					if buffer[position] != rune('<') {
-						goto l336
-					}
-					position++
-					goto l332
+					goto l333
 				l336:
-					position, tokenIndex = position332, tokenIndex332
+					position, tokenIndex = position333, tokenIndex333
+					if buffer[position] != rune('<') {
+						goto l337
+					}
+					position++
+					if buffer[position] != rune('<') {
+						goto l337
+					}
+					position++
+					goto l333
+				l337:
+					position, tokenIndex = position333, tokenIndex333
 					if buffer[position] != rune('>') {
-						goto l330
+						goto l331
 					}
 					position++
 					if buffer[position] != rune('>') {
-						goto l330
+						goto l331
 					}
 					position++
 				}
-			l332:
-				add(ruleSymbolOperator, position331)
+			l333:
+				add(ruleSymbolOperator, position332)
 			}
 			return true
-		l330:
-			position, tokenIndex = position330, tokenIndex330
+		l331:
+			position, tokenIndex = position331, tokenIndex331
 			return false
 		},
 		/* 19 OpenParen <- <'('> */
 		func() bool {
-			position337, tokenIndex337 := position, tokenIndex
+			position338, tokenIndex338 := position, tokenIndex
 			{
-				position338 := position
+				position339 := position
 				if buffer[position] != rune('(') {
-					goto l337
+					goto l338
 				}
 				position++
-				add(ruleOpenParen, position338)
+				add(ruleOpenParen, position339)
 			}
 			return true
-		l337:
-			position, tokenIndex = position337, tokenIndex337
+		l338:
+			position, tokenIndex = position338, tokenIndex338
 			return false
 		},
 		/* 20 CloseParen <- <')'> */
 		func() bool {
-			position339, tokenIndex339 := position, tokenIndex
+			position340, tokenIndex340 := position, tokenIndex
 			{
-				position340 := position
+				position341 := position
 				if buffer[position] != rune(')') {
-					goto l339
+					goto l340
 				}
 				position++
-				add(ruleCloseParen, position340)
+				add(ruleCloseParen, position341)
 			}
 			return true
-		l339:
-			position, tokenIndex = position339, tokenIndex339
+		l340:
+			position, tokenIndex = position340, tokenIndex340
 			return false
 		},
 		/* 21 SymbolType <- <(('@' / '%') (('f' 'u' 'n' 'c' 't' 'i' 'o' 'n') / ('o' 'b' 'j' 'e' 'c' 't')))> */
 		func() bool {
-			position341, tokenIndex341 := position, tokenIndex
+			position342, tokenIndex342 := position, tokenIndex
 			{
-				position342 := position
+				position343 := position
 				{
-					position343, tokenIndex343 := position, tokenIndex
+					position344, tokenIndex344 := position, tokenIndex
 					if buffer[position] != rune('@') {
-						goto l344
+						goto l345
 					}
 					position++
-					goto l343
-				l344:
-					position, tokenIndex = position343, tokenIndex343
+					goto l344
+				l345:
+					position, tokenIndex = position344, tokenIndex344
 					if buffer[position] != rune('%') {
-						goto l341
+						goto l342
 					}
 					position++
 				}
-			l343:
+			l344:
 				{
-					position345, tokenIndex345 := position, tokenIndex
+					position346, tokenIndex346 := position, tokenIndex
 					if buffer[position] != rune('f') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('u') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('n') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('c') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('t') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('i') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('o') {
-						goto l346
+						goto l347
 					}
 					position++
 					if buffer[position] != rune('n') {
-						goto l346
+						goto l347
 					}
 					position++
-					goto l345
-				l346:
-					position, tokenIndex = position345, tokenIndex345
+					goto l346
+				l347:
+					position, tokenIndex = position346, tokenIndex346
 					if buffer[position] != rune('o') {
-						goto l341
+						goto l342
 					}
 					position++
 					if buffer[position] != rune('b') {
-						goto l341
+						goto l342
 					}
 					position++
 					if buffer[position] != rune('j') {
-						goto l341
+						goto l342
 					}
 					position++
 					if buffer[position] != rune('e') {
-						goto l341
+						goto l342
 					}
 					position++
 					if buffer[position] != rune('c') {
-						goto l341
+						goto l342
 					}
 					position++
 					if buffer[position] != rune('t') {
-						goto l341
+						goto l342
 					}
 					position++
 				}
-			l345:
-				add(ruleSymbolType, position342)
+			l346:
+				add(ruleSymbolType, position343)
 			}
 			return true
-		l341:
-			position, tokenIndex = position341, tokenIndex341
+		l342:
+			position, tokenIndex = position342, tokenIndex342
 			return false
 		},
 		/* 22 Dot <- <'.'> */
 		func() bool {
-			position347, tokenIndex347 := position, tokenIndex
+			position348, tokenIndex348 := position, tokenIndex
 			{
-				position348 := position
+				position349 := position
 				if buffer[position] != rune('.') {
-					goto l347
+					goto l348
 				}
 				position++
-				add(ruleDot, position348)
+				add(ruleDot, position349)
 			}
 			return true
-		l347:
-			position, tokenIndex = position347, tokenIndex347
+		l348:
+			position, tokenIndex = position348, tokenIndex348
 			return false
 		},
 		/* 23 TCMarker <- <('[' 'T' 'C' ']')> */
 		func() bool {
-			position349, tokenIndex349 := position, tokenIndex
+			position350, tokenIndex350 := position, tokenIndex
 			{
-				position350 := position
+				position351 := position
 				if buffer[position] != rune('[') {
-					goto l349
+					goto l350
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l349
+					goto l350
 				}
 				position++
 				if buffer[position] != rune('C') {
-					goto l349
+					goto l350
 				}
 				position++
 				if buffer[position] != rune(']') {
-					goto l349
+					goto l350
 				}
 				position++
-				add(ruleTCMarker, position350)
+				add(ruleTCMarker, position351)
 			}
 			return true
-		l349:
-			position, tokenIndex = position349, tokenIndex349
+		l350:
+			position, tokenIndex = position350, tokenIndex350
 			return false
 		},
 		/* 24 EscapedChar <- <('\\' .)> */
 		func() bool {
-			position351, tokenIndex351 := position, tokenIndex
+			position352, tokenIndex352 := position, tokenIndex
 			{
-				position352 := position
+				position353 := position
 				if buffer[position] != rune('\\') {
-					goto l351
+					goto l352
 				}
 				position++
 				if !matchDot() {
-					goto l351
+					goto l352
 				}
-				add(ruleEscapedChar, position352)
+				add(ruleEscapedChar, position353)
 			}
 			return true
-		l351:
-			position, tokenIndex = position351, tokenIndex351
+		l352:
+			position, tokenIndex = position352, tokenIndex352
 			return false
 		},
 		/* 25 WS <- <(' ' / '\t')+> */
 		func() bool {
-			position353, tokenIndex353 := position, tokenIndex
+			position354, tokenIndex354 := position, tokenIndex
 			{
-				position354 := position
+				position355 := position
+				{
+					position358, tokenIndex358 := position, tokenIndex
+					if buffer[position] != rune(' ') {
+						goto l359
+					}
+					position++
+					goto l358
+				l359:
+					position, tokenIndex = position358, tokenIndex358
+					if buffer[position] != rune('\t') {
+						goto l354
+					}
+					position++
+				}
+			l358:
+			l356:
 				{
 					position357, tokenIndex357 := position, tokenIndex
-					if buffer[position] != rune(' ') {
-						goto l358
-					}
-					position++
-					goto l357
-				l358:
-					position, tokenIndex = position357, tokenIndex357
-					if buffer[position] != rune('\t') {
-						goto l353
-					}
-					position++
-				}
-			l357:
-			l355:
-				{
-					position356, tokenIndex356 := position, tokenIndex
 					{
-						position359, tokenIndex359 := position, tokenIndex
+						position360, tokenIndex360 := position, tokenIndex
 						if buffer[position] != rune(' ') {
-							goto l360
+							goto l361
 						}
 						position++
-						goto l359
-					l360:
-						position, tokenIndex = position359, tokenIndex359
+						goto l360
+					l361:
+						position, tokenIndex = position360, tokenIndex360
 						if buffer[position] != rune('\t') {
-							goto l356
+							goto l357
 						}
 						position++
 					}
-				l359:
-					goto l355
-				l356:
-					position, tokenIndex = position356, tokenIndex356
+				l360:
+					goto l356
+				l357:
+					position, tokenIndex = position357, tokenIndex357
 				}
-				add(ruleWS, position354)
+				add(ruleWS, position355)
 			}
 			return true
-		l353:
-			position, tokenIndex = position353, tokenIndex353
+		l354:
+			position, tokenIndex = position354, tokenIndex354
 			return false
 		},
 		/* 26 Comment <- <((('/' '/') / '#') (!'\n' .)*)> */
 		func() bool {
-			position361, tokenIndex361 := position, tokenIndex
+			position362, tokenIndex362 := position, tokenIndex
 			{
-				position362 := position
+				position363 := position
 				{
-					position363, tokenIndex363 := position, tokenIndex
+					position364, tokenIndex364 := position, tokenIndex
 					if buffer[position] != rune('/') {
-						goto l364
+						goto l365
 					}
 					position++
 					if buffer[position] != rune('/') {
-						goto l364
+						goto l365
 					}
 					position++
-					goto l363
-				l364:
-					position, tokenIndex = position363, tokenIndex363
+					goto l364
+				l365:
+					position, tokenIndex = position364, tokenIndex364
 					if buffer[position] != rune('#') {
-						goto l361
+						goto l362
 					}
 					position++
 				}
-			l363:
-			l365:
+			l364:
+			l366:
 				{
-					position366, tokenIndex366 := position, tokenIndex
+					position367, tokenIndex367 := position, tokenIndex
 					{
-						position367, tokenIndex367 := position, tokenIndex
+						position368, tokenIndex368 := position, tokenIndex
 						if buffer[position] != rune('\n') {
-							goto l367
+							goto l368
 						}
 						position++
-						goto l366
-					l367:
-						position, tokenIndex = position367, tokenIndex367
+						goto l367
+					l368:
+						position, tokenIndex = position368, tokenIndex368
 					}
 					if !matchDot() {
-						goto l366
+						goto l367
 					}
-					goto l365
-				l366:
-					position, tokenIndex = position366, tokenIndex366
+					goto l366
+				l367:
+					position, tokenIndex = position367, tokenIndex367
 				}
-				add(ruleComment, position362)
+				add(ruleComment, position363)
 			}
 			return true
-		l361:
-			position, tokenIndex = position361, tokenIndex361
+		l362:
+			position, tokenIndex = position362, tokenIndex362
 			return false
 		},
 		/* 27 Label <- <((LocalSymbol / LocalLabel / SymbolName) ':')> */
 		func() bool {
-			position368, tokenIndex368 := position, tokenIndex
+			position369, tokenIndex369 := position, tokenIndex
 			{
-				position369 := position
+				position370 := position
 				{
-					position370, tokenIndex370 := position, tokenIndex
+					position371, tokenIndex371 := position, tokenIndex
 					if !_rules[ruleLocalSymbol]() {
-						goto l371
-					}
-					goto l370
-				l371:
-					position, tokenIndex = position370, tokenIndex370
-					if !_rules[ruleLocalLabel]() {
 						goto l372
 					}
-					goto l370
+					goto l371
 				l372:
-					position, tokenIndex = position370, tokenIndex370
+					position, tokenIndex = position371, tokenIndex371
+					if !_rules[ruleLocalLabel]() {
+						goto l373
+					}
+					goto l371
+				l373:
+					position, tokenIndex = position371, tokenIndex371
 					if !_rules[ruleSymbolName]() {
-						goto l368
+						goto l369
 					}
 				}
-			l370:
+			l371:
 				if buffer[position] != rune(':') {
-					goto l368
+					goto l369
 				}
 				position++
-				add(ruleLabel, position369)
+				add(ruleLabel, position370)
 			}
 			return true
-		l368:
-			position, tokenIndex = position368, tokenIndex368
+		l369:
+			position, tokenIndex = position369, tokenIndex369
 			return false
 		},
 		/* 28 SymbolName <- <(([a-z] / [A-Z] / '.' / '_') ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')*)> */
 		func() bool {
-			position373, tokenIndex373 := position, tokenIndex
+			position374, tokenIndex374 := position, tokenIndex
 			{
-				position374 := position
+				position375 := position
 				{
-					position375, tokenIndex375 := position, tokenIndex
+					position376, tokenIndex376 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l376
-					}
-					position++
-					goto l375
-				l376:
-					position, tokenIndex = position375, tokenIndex375
-					if c := buffer[position]; c < rune('A') || c > rune('Z') {
 						goto l377
 					}
 					position++
-					goto l375
+					goto l376
 				l377:
-					position, tokenIndex = position375, tokenIndex375
-					if buffer[position] != rune('.') {
+					position, tokenIndex = position376, tokenIndex376
+					if c := buffer[position]; c < rune('A') || c > rune('Z') {
 						goto l378
 					}
 					position++
-					goto l375
+					goto l376
 				l378:
-					position, tokenIndex = position375, tokenIndex375
+					position, tokenIndex = position376, tokenIndex376
+					if buffer[position] != rune('.') {
+						goto l379
+					}
+					position++
+					goto l376
+				l379:
+					position, tokenIndex = position376, tokenIndex376
 					if buffer[position] != rune('_') {
-						goto l373
+						goto l374
 					}
 					position++
 				}
-			l375:
-			l379:
+			l376:
+			l380:
 				{
-					position380, tokenIndex380 := position, tokenIndex
+					position381, tokenIndex381 := position, tokenIndex
 					{
-						position381, tokenIndex381 := position, tokenIndex
+						position382, tokenIndex382 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l382
-						}
-						position++
-						goto l381
-					l382:
-						position, tokenIndex = position381, tokenIndex381
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l383
 						}
 						position++
-						goto l381
+						goto l382
 					l383:
-						position, tokenIndex = position381, tokenIndex381
-						if buffer[position] != rune('.') {
+						position, tokenIndex = position382, tokenIndex382
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l384
 						}
 						position++
-						goto l381
+						goto l382
 					l384:
-						position, tokenIndex = position381, tokenIndex381
-						{
-							position386, tokenIndex386 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l387
-							}
-							position++
-							goto l386
-						l387:
-							position, tokenIndex = position386, tokenIndex386
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l385
-							}
-							position++
-						}
-					l386:
-						goto l381
-					l385:
-						position, tokenIndex = position381, tokenIndex381
-						if buffer[position] != rune('$') {
-							goto l388
+						position, tokenIndex = position382, tokenIndex382
+						if buffer[position] != rune('.') {
+							goto l385
 						}
 						position++
-						goto l381
-					l388:
-						position, tokenIndex = position381, tokenIndex381
+						goto l382
+					l385:
+						position, tokenIndex = position382, tokenIndex382
+						{
+							position387, tokenIndex387 := position, tokenIndex
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l388
+							}
+							position++
+							goto l387
+						l388:
+							position, tokenIndex = position387, tokenIndex387
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l386
+							}
+							position++
+						}
+					l387:
+						goto l382
+					l386:
+						position, tokenIndex = position382, tokenIndex382
+						if buffer[position] != rune('$') {
+							goto l389
+						}
+						position++
+						goto l382
+					l389:
+						position, tokenIndex = position382, tokenIndex382
 						if buffer[position] != rune('_') {
-							goto l380
+							goto l381
 						}
 						position++
 					}
+				l382:
+					goto l380
 				l381:
-					goto l379
-				l380:
-					position, tokenIndex = position380, tokenIndex380
+					position, tokenIndex = position381, tokenIndex381
 				}
-				add(ruleSymbolName, position374)
+				add(ruleSymbolName, position375)
 			}
 			return true
-		l373:
-			position, tokenIndex = position373, tokenIndex373
+		l374:
+			position, tokenIndex = position374, tokenIndex374
 			return false
 		},
 		/* 29 LocalSymbol <- <('.' 'L' ([a-z] / [A-Z] / ([a-z] / [A-Z]) / '.' / ([0-9] / [0-9]) / '$' / '_')+)> */
 		func() bool {
-			position389, tokenIndex389 := position, tokenIndex
+			position390, tokenIndex390 := position, tokenIndex
 			{
-				position390 := position
+				position391 := position
 				if buffer[position] != rune('.') {
-					goto l389
+					goto l390
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l389
+					goto l390
 				}
 				position++
 				{
-					position393, tokenIndex393 := position, tokenIndex
+					position394, tokenIndex394 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l394
-					}
-					position++
-					goto l393
-				l394:
-					position, tokenIndex = position393, tokenIndex393
-					if c := buffer[position]; c < rune('A') || c > rune('Z') {
 						goto l395
 					}
 					position++
-					goto l393
+					goto l394
 				l395:
-					position, tokenIndex = position393, tokenIndex393
-					{
-						position397, tokenIndex397 := position, tokenIndex
-						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l398
-						}
-						position++
-						goto l397
-					l398:
-						position, tokenIndex = position397, tokenIndex397
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l396
-						}
-						position++
+					position, tokenIndex = position394, tokenIndex394
+					if c := buffer[position]; c < rune('A') || c > rune('Z') {
+						goto l396
 					}
-				l397:
-					goto l393
+					position++
+					goto l394
 				l396:
-					position, tokenIndex = position393, tokenIndex393
-					if buffer[position] != rune('.') {
-						goto l399
-					}
-					position++
-					goto l393
-				l399:
-					position, tokenIndex = position393, tokenIndex393
+					position, tokenIndex = position394, tokenIndex394
 					{
-						position401, tokenIndex401 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l402
+						position398, tokenIndex398 := position, tokenIndex
+						if c := buffer[position]; c < rune('a') || c > rune('z') {
+							goto l399
 						}
 						position++
-						goto l401
-					l402:
-						position, tokenIndex = position401, tokenIndex401
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l400
+						goto l398
+					l399:
+						position, tokenIndex = position398, tokenIndex398
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
+							goto l397
 						}
 						position++
 					}
-				l401:
-					goto l393
-				l400:
-					position, tokenIndex = position393, tokenIndex393
-					if buffer[position] != rune('$') {
-						goto l403
+				l398:
+					goto l394
+				l397:
+					position, tokenIndex = position394, tokenIndex394
+					if buffer[position] != rune('.') {
+						goto l400
 					}
 					position++
-					goto l393
-				l403:
-					position, tokenIndex = position393, tokenIndex393
+					goto l394
+				l400:
+					position, tokenIndex = position394, tokenIndex394
+					{
+						position402, tokenIndex402 := position, tokenIndex
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l403
+						}
+						position++
+						goto l402
+					l403:
+						position, tokenIndex = position402, tokenIndex402
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l401
+						}
+						position++
+					}
+				l402:
+					goto l394
+				l401:
+					position, tokenIndex = position394, tokenIndex394
+					if buffer[position] != rune('$') {
+						goto l404
+					}
+					position++
+					goto l394
+				l404:
+					position, tokenIndex = position394, tokenIndex394
 					if buffer[position] != rune('_') {
-						goto l389
+						goto l390
 					}
 					position++
 				}
-			l393:
-			l391:
+			l394:
+			l392:
 				{
-					position392, tokenIndex392 := position, tokenIndex
+					position393, tokenIndex393 := position, tokenIndex
 					{
-						position404, tokenIndex404 := position, tokenIndex
+						position405, tokenIndex405 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l405
-						}
-						position++
-						goto l404
-					l405:
-						position, tokenIndex = position404, tokenIndex404
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l406
 						}
 						position++
-						goto l404
+						goto l405
 					l406:
-						position, tokenIndex = position404, tokenIndex404
-						{
-							position408, tokenIndex408 := position, tokenIndex
-							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l409
-							}
-							position++
-							goto l408
-						l409:
-							position, tokenIndex = position408, tokenIndex408
-							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l407
-							}
-							position++
+						position, tokenIndex = position405, tokenIndex405
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
+							goto l407
 						}
-					l408:
-						goto l404
+						position++
+						goto l405
 					l407:
-						position, tokenIndex = position404, tokenIndex404
-						if buffer[position] != rune('.') {
-							goto l410
-						}
-						position++
-						goto l404
-					l410:
-						position, tokenIndex = position404, tokenIndex404
+						position, tokenIndex = position405, tokenIndex405
 						{
-							position412, tokenIndex412 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l413
+							position409, tokenIndex409 := position, tokenIndex
+							if c := buffer[position]; c < rune('a') || c > rune('z') {
+								goto l410
 							}
 							position++
-							goto l412
-						l413:
-							position, tokenIndex = position412, tokenIndex412
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l411
+							goto l409
+						l410:
+							position, tokenIndex = position409, tokenIndex409
+							if c := buffer[position]; c < rune('A') || c > rune('Z') {
+								goto l408
 							}
 							position++
 						}
-					l412:
-						goto l404
-					l411:
-						position, tokenIndex = position404, tokenIndex404
-						if buffer[position] != rune('$') {
-							goto l414
+					l409:
+						goto l405
+					l408:
+						position, tokenIndex = position405, tokenIndex405
+						if buffer[position] != rune('.') {
+							goto l411
 						}
 						position++
-						goto l404
-					l414:
-						position, tokenIndex = position404, tokenIndex404
+						goto l405
+					l411:
+						position, tokenIndex = position405, tokenIndex405
+						{
+							position413, tokenIndex413 := position, tokenIndex
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l414
+							}
+							position++
+							goto l413
+						l414:
+							position, tokenIndex = position413, tokenIndex413
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l412
+							}
+							position++
+						}
+					l413:
+						goto l405
+					l412:
+						position, tokenIndex = position405, tokenIndex405
+						if buffer[position] != rune('$') {
+							goto l415
+						}
+						position++
+						goto l405
+					l415:
+						position, tokenIndex = position405, tokenIndex405
 						if buffer[position] != rune('_') {
-							goto l392
+							goto l393
 						}
 						position++
 					}
-				l404:
-					goto l391
-				l392:
-					position, tokenIndex = position392, tokenIndex392
+				l405:
+					goto l392
+				l393:
+					position, tokenIndex = position393, tokenIndex393
 				}
-				add(ruleLocalSymbol, position390)
+				add(ruleLocalSymbol, position391)
 			}
 			return true
-		l389:
-			position, tokenIndex = position389, tokenIndex389
+		l390:
+			position, tokenIndex = position390, tokenIndex390
 			return false
 		},
 		/* 30 LocalLabel <- <([0-9] ([0-9] / '$')*)> */
 		func() bool {
-			position415, tokenIndex415 := position, tokenIndex
+			position416, tokenIndex416 := position, tokenIndex
 			{
-				position416 := position
+				position417 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l415
+					goto l416
 				}
 				position++
-			l417:
+			l418:
 				{
-					position418, tokenIndex418 := position, tokenIndex
+					position419, tokenIndex419 := position, tokenIndex
 					{
-						position419, tokenIndex419 := position, tokenIndex
+						position420, tokenIndex420 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l420
+							goto l421
 						}
 						position++
-						goto l419
-					l420:
-						position, tokenIndex = position419, tokenIndex419
+						goto l420
+					l421:
+						position, tokenIndex = position420, tokenIndex420
 						if buffer[position] != rune('$') {
-							goto l418
+							goto l419
 						}
 						position++
 					}
+				l420:
+					goto l418
 				l419:
-					goto l417
-				l418:
-					position, tokenIndex = position418, tokenIndex418
+					position, tokenIndex = position419, tokenIndex419
 				}
-				add(ruleLocalLabel, position416)
+				add(ruleLocalLabel, position417)
 			}
 			return true
-		l415:
-			position, tokenIndex = position415, tokenIndex415
+		l416:
+			position, tokenIndex = position416, tokenIndex416
 			return false
 		},
 		/* 31 LocalLabelRef <- <([0-9] ([0-9] / '$')* ('b' / 'f'))> */
 		func() bool {
-			position421, tokenIndex421 := position, tokenIndex
+			position422, tokenIndex422 := position, tokenIndex
 			{
-				position422 := position
+				position423 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l421
+					goto l422
 				}
 				position++
-			l423:
+			l424:
 				{
-					position424, tokenIndex424 := position, tokenIndex
+					position425, tokenIndex425 := position, tokenIndex
 					{
-						position425, tokenIndex425 := position, tokenIndex
+						position426, tokenIndex426 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l426
+							goto l427
 						}
 						position++
-						goto l425
-					l426:
-						position, tokenIndex = position425, tokenIndex425
+						goto l426
+					l427:
+						position, tokenIndex = position426, tokenIndex426
 						if buffer[position] != rune('$') {
-							goto l424
+							goto l425
 						}
 						position++
 					}
+				l426:
+					goto l424
 				l425:
-					goto l423
-				l424:
-					position, tokenIndex = position424, tokenIndex424
+					position, tokenIndex = position425, tokenIndex425
 				}
 				{
-					position427, tokenIndex427 := position, tokenIndex
+					position428, tokenIndex428 := position, tokenIndex
 					if buffer[position] != rune('b') {
-						goto l428
+						goto l429
 					}
 					position++
-					goto l427
-				l428:
-					position, tokenIndex = position427, tokenIndex427
+					goto l428
+				l429:
+					position, tokenIndex = position428, tokenIndex428
 					if buffer[position] != rune('f') {
-						goto l421
+						goto l422
 					}
 					position++
 				}
-			l427:
-				add(ruleLocalLabelRef, position422)
+			l428:
+				add(ruleLocalLabelRef, position423)
 			}
 			return true
-		l421:
-			position, tokenIndex = position421, tokenIndex421
+		l422:
+			position, tokenIndex = position422, tokenIndex422
 			return false
 		},
 		/* 32 InstructionPrefix <- <(('n' / 'N') ('o' / 'O') ('t' / 'T') ('r' / 'R') ('a' / 'A') ('c' / 'C') ('k' / 'K'))> */
 		func() bool {
-			position429, tokenIndex429 := position, tokenIndex
+			position430, tokenIndex430 := position, tokenIndex
 			{
-				position430 := position
+				position431 := position
 				{
-					position431, tokenIndex431 := position, tokenIndex
+					position432, tokenIndex432 := position, tokenIndex
 					if buffer[position] != rune('n') {
-						goto l432
+						goto l433
 					}
 					position++
-					goto l431
-				l432:
-					position, tokenIndex = position431, tokenIndex431
+					goto l432
+				l433:
+					position, tokenIndex = position432, tokenIndex432
 					if buffer[position] != rune('N') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l431:
+			l432:
 				{
-					position433, tokenIndex433 := position, tokenIndex
+					position434, tokenIndex434 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l434
+						goto l435
 					}
 					position++
-					goto l433
-				l434:
-					position, tokenIndex = position433, tokenIndex433
+					goto l434
+				l435:
+					position, tokenIndex = position434, tokenIndex434
 					if buffer[position] != rune('O') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l433:
+			l434:
 				{
-					position435, tokenIndex435 := position, tokenIndex
+					position436, tokenIndex436 := position, tokenIndex
 					if buffer[position] != rune('t') {
-						goto l436
+						goto l437
 					}
 					position++
-					goto l435
-				l436:
-					position, tokenIndex = position435, tokenIndex435
+					goto l436
+				l437:
+					position, tokenIndex = position436, tokenIndex436
 					if buffer[position] != rune('T') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l435:
+			l436:
 				{
-					position437, tokenIndex437 := position, tokenIndex
+					position438, tokenIndex438 := position, tokenIndex
 					if buffer[position] != rune('r') {
-						goto l438
+						goto l439
 					}
 					position++
-					goto l437
-				l438:
-					position, tokenIndex = position437, tokenIndex437
+					goto l438
+				l439:
+					position, tokenIndex = position438, tokenIndex438
 					if buffer[position] != rune('R') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l437:
+			l438:
 				{
-					position439, tokenIndex439 := position, tokenIndex
+					position440, tokenIndex440 := position, tokenIndex
 					if buffer[position] != rune('a') {
-						goto l440
+						goto l441
 					}
 					position++
-					goto l439
-				l440:
-					position, tokenIndex = position439, tokenIndex439
+					goto l440
+				l441:
+					position, tokenIndex = position440, tokenIndex440
 					if buffer[position] != rune('A') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l439:
+			l440:
 				{
-					position441, tokenIndex441 := position, tokenIndex
+					position442, tokenIndex442 := position, tokenIndex
 					if buffer[position] != rune('c') {
-						goto l442
+						goto l443
 					}
 					position++
-					goto l441
-				l442:
-					position, tokenIndex = position441, tokenIndex441
+					goto l442
+				l443:
+					position, tokenIndex = position442, tokenIndex442
 					if buffer[position] != rune('C') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l441:
+			l442:
 				{
-					position443, tokenIndex443 := position, tokenIndex
+					position444, tokenIndex444 := position, tokenIndex
 					if buffer[position] != rune('k') {
-						goto l444
+						goto l445
 					}
 					position++
-					goto l443
-				l444:
-					position, tokenIndex = position443, tokenIndex443
+					goto l444
+				l445:
+					position, tokenIndex = position444, tokenIndex444
 					if buffer[position] != rune('K') {
-						goto l429
+						goto l430
 					}
 					position++
 				}
-			l443:
-				add(ruleInstructionPrefix, position430)
+			l444:
+				add(ruleInstructionPrefix, position431)
 			}
 			return true
-		l429:
-			position, tokenIndex = position429, tokenIndex429
+		l430:
+			position, tokenIndex = position430, tokenIndex430
 			return false
 		},
 		/* 33 Instruction <- <((InstructionPrefix WS)? InstructionName (WS InstructionArg (WS? ',' WS? InstructionArg)*)?)> */
 		func() bool {
-			position445, tokenIndex445 := position, tokenIndex
+			position446, tokenIndex446 := position, tokenIndex
 			{
-				position446 := position
+				position447 := position
 				{
-					position447, tokenIndex447 := position, tokenIndex
+					position448, tokenIndex448 := position, tokenIndex
 					if !_rules[ruleInstructionPrefix]() {
-						goto l447
+						goto l448
 					}
 					if !_rules[ruleWS]() {
-						goto l447
+						goto l448
 					}
-					goto l448
-				l447:
-					position, tokenIndex = position447, tokenIndex447
+					goto l449
+				l448:
+					position, tokenIndex = position448, tokenIndex448
 				}
-			l448:
+			l449:
 				if !_rules[ruleInstructionName]() {
-					goto l445
+					goto l446
 				}
 				{
-					position449, tokenIndex449 := position, tokenIndex
+					position450, tokenIndex450 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l449
+						goto l450
 					}
 					if !_rules[ruleInstructionArg]() {
-						goto l449
+						goto l450
 					}
-				l451:
+				l452:
 					{
-						position452, tokenIndex452 := position, tokenIndex
+						position453, tokenIndex453 := position, tokenIndex
 						{
-							position453, tokenIndex453 := position, tokenIndex
+							position454, tokenIndex454 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l453
+								goto l454
 							}
-							goto l454
-						l453:
-							position, tokenIndex = position453, tokenIndex453
+							goto l455
+						l454:
+							position, tokenIndex = position454, tokenIndex454
 						}
-					l454:
+					l455:
 						if buffer[position] != rune(',') {
-							goto l452
+							goto l453
 						}
 						position++
 						{
-							position455, tokenIndex455 := position, tokenIndex
+							position456, tokenIndex456 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l455
+								goto l456
 							}
-							goto l456
-						l455:
-							position, tokenIndex = position455, tokenIndex455
+							goto l457
+						l456:
+							position, tokenIndex = position456, tokenIndex456
 						}
-					l456:
+					l457:
 						if !_rules[ruleInstructionArg]() {
-							goto l452
+							goto l453
 						}
-						goto l451
-					l452:
-						position, tokenIndex = position452, tokenIndex452
+						goto l452
+					l453:
+						position, tokenIndex = position453, tokenIndex453
 					}
-					goto l450
-				l449:
-					position, tokenIndex = position449, tokenIndex449
+					goto l451
+				l450:
+					position, tokenIndex = position450, tokenIndex450
 				}
-			l450:
-				add(ruleInstruction, position446)
+			l451:
+				add(ruleInstruction, position447)
 			}
 			return true
-		l445:
-			position, tokenIndex = position445, tokenIndex445
+		l446:
+			position, tokenIndex = position446, tokenIndex446
 			return false
 		},
 		/* 34 InstructionName <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]))* ('.' / '+' / '-')?)> */
 		func() bool {
-			position457, tokenIndex457 := position, tokenIndex
+			position458, tokenIndex458 := position, tokenIndex
 			{
-				position458 := position
+				position459 := position
 				{
-					position459, tokenIndex459 := position, tokenIndex
+					position460, tokenIndex460 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l460
+						goto l461
 					}
 					position++
-					goto l459
-				l460:
-					position, tokenIndex = position459, tokenIndex459
+					goto l460
+				l461:
+					position, tokenIndex = position460, tokenIndex460
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l457
+						goto l458
 					}
 					position++
 				}
-			l459:
-			l461:
+			l460:
+			l462:
 				{
-					position462, tokenIndex462 := position, tokenIndex
+					position463, tokenIndex463 := position, tokenIndex
 					{
-						position463, tokenIndex463 := position, tokenIndex
+						position464, tokenIndex464 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l464
-						}
-						position++
-						goto l463
-					l464:
-						position, tokenIndex = position463, tokenIndex463
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l465
 						}
 						position++
-						goto l463
+						goto l464
 					l465:
-						position, tokenIndex = position463, tokenIndex463
-						if buffer[position] != rune('.') {
+						position, tokenIndex = position464, tokenIndex464
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l466
 						}
 						position++
-						goto l463
+						goto l464
 					l466:
-						position, tokenIndex = position463, tokenIndex463
-						{
-							position467, tokenIndex467 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l468
-							}
-							position++
-							goto l467
-						l468:
-							position, tokenIndex = position467, tokenIndex467
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l462
-							}
-							position++
-						}
-					l467:
-					}
-				l463:
-					goto l461
-				l462:
-					position, tokenIndex = position462, tokenIndex462
-				}
-				{
-					position469, tokenIndex469 := position, tokenIndex
-					{
-						position471, tokenIndex471 := position, tokenIndex
+						position, tokenIndex = position464, tokenIndex464
 						if buffer[position] != rune('.') {
-							goto l472
+							goto l467
 						}
 						position++
-						goto l471
-					l472:
-						position, tokenIndex = position471, tokenIndex471
-						if buffer[position] != rune('+') {
+						goto l464
+					l467:
+						position, tokenIndex = position464, tokenIndex464
+						{
+							position468, tokenIndex468 := position, tokenIndex
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l469
+							}
+							position++
+							goto l468
+						l469:
+							position, tokenIndex = position468, tokenIndex468
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l463
+							}
+							position++
+						}
+					l468:
+					}
+				l464:
+					goto l462
+				l463:
+					position, tokenIndex = position463, tokenIndex463
+				}
+				{
+					position470, tokenIndex470 := position, tokenIndex
+					{
+						position472, tokenIndex472 := position, tokenIndex
+						if buffer[position] != rune('.') {
 							goto l473
 						}
 						position++
-						goto l471
+						goto l472
 					l473:
-						position, tokenIndex = position471, tokenIndex471
+						position, tokenIndex = position472, tokenIndex472
+						if buffer[position] != rune('+') {
+							goto l474
+						}
+						position++
+						goto l472
+					l474:
+						position, tokenIndex = position472, tokenIndex472
 						if buffer[position] != rune('-') {
-							goto l469
+							goto l470
 						}
 						position++
 					}
-				l471:
-					goto l470
-				l469:
-					position, tokenIndex = position469, tokenIndex469
+				l472:
+					goto l471
+				l470:
+					position, tokenIndex = position470, tokenIndex470
 				}
-			l470:
-				add(ruleInstructionName, position458)
+			l471:
+				add(ruleInstructionName, position459)
 			}
 			return true
-		l457:
-			position, tokenIndex = position457, tokenIndex457
+		l458:
+			position, tokenIndex = position458, tokenIndex458
 			return false
 		},
 		/* 35 InstructionArg <- <(IndirectionIndicator? (ARMConstantTweak / RegisterOrConstant / LocalLabelRef / TOCRefHigh / TOCRefLow / GOTLocation / GOTAddress / GOTSymbolOffset / MemoryRef) AVX512Token*)> */
 		func() bool {
-			position474, tokenIndex474 := position, tokenIndex
+			position475, tokenIndex475 := position, tokenIndex
 			{
-				position475 := position
+				position476 := position
 				{
-					position476, tokenIndex476 := position, tokenIndex
+					position477, tokenIndex477 := position, tokenIndex
 					if !_rules[ruleIndirectionIndicator]() {
-						goto l476
-					}
-					goto l477
-				l476:
-					position, tokenIndex = position476, tokenIndex476
-				}
-			l477:
-				{
-					position478, tokenIndex478 := position, tokenIndex
-					if !_rules[ruleARMConstantTweak]() {
-						goto l479
+						goto l477
 					}
 					goto l478
-				l479:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleRegisterOrConstant]() {
-						goto l480
-					}
-					goto l478
-				l480:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleLocalLabelRef]() {
-						goto l481
-					}
-					goto l478
-				l481:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleTOCRefHigh]() {
-						goto l482
-					}
-					goto l478
-				l482:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleTOCRefLow]() {
-						goto l483
-					}
-					goto l478
-				l483:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleGOTLocation]() {
-						goto l484
-					}
-					goto l478
-				l484:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleGOTAddress]() {
-						goto l485
-					}
-					goto l478
-				l485:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleGOTSymbolOffset]() {
-						goto l486
-					}
-					goto l478
-				l486:
-					position, tokenIndex = position478, tokenIndex478
-					if !_rules[ruleMemoryRef]() {
-						goto l474
-					}
+				l477:
+					position, tokenIndex = position477, tokenIndex477
 				}
 			l478:
-			l487:
 				{
-					position488, tokenIndex488 := position, tokenIndex
-					if !_rules[ruleAVX512Token]() {
-						goto l488
+					position479, tokenIndex479 := position, tokenIndex
+					if !_rules[ruleARMConstantTweak]() {
+						goto l480
 					}
-					goto l487
-				l488:
-					position, tokenIndex = position488, tokenIndex488
+					goto l479
+				l480:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleRegisterOrConstant]() {
+						goto l481
+					}
+					goto l479
+				l481:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleLocalLabelRef]() {
+						goto l482
+					}
+					goto l479
+				l482:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleTOCRefHigh]() {
+						goto l483
+					}
+					goto l479
+				l483:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleTOCRefLow]() {
+						goto l484
+					}
+					goto l479
+				l484:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleGOTLocation]() {
+						goto l485
+					}
+					goto l479
+				l485:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleGOTAddress]() {
+						goto l486
+					}
+					goto l479
+				l486:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleGOTSymbolOffset]() {
+						goto l487
+					}
+					goto l479
+				l487:
+					position, tokenIndex = position479, tokenIndex479
+					if !_rules[ruleMemoryRef]() {
+						goto l475
+					}
 				}
-				add(ruleInstructionArg, position475)
+			l479:
+			l488:
+				{
+					position489, tokenIndex489 := position, tokenIndex
+					if !_rules[ruleAVX512Token]() {
+						goto l489
+					}
+					goto l488
+				l489:
+					position, tokenIndex = position489, tokenIndex489
+				}
+				add(ruleInstructionArg, position476)
 			}
 			return true
-		l474:
-			position, tokenIndex = position474, tokenIndex474
+		l475:
+			position, tokenIndex = position475, tokenIndex475
 			return false
 		},
 		/* 36 GOTLocation <- <('$' '_' 'G' 'L' 'O' 'B' 'A' 'L' '_' 'O' 'F' 'F' 'S' 'E' 'T' '_' 'T' 'A' 'B' 'L' 'E' '_' '-' LocalSymbol)> */
 		func() bool {
-			position489, tokenIndex489 := position, tokenIndex
+			position490, tokenIndex490 := position, tokenIndex
 			{
-				position490 := position
+				position491 := position
 				if buffer[position] != rune('$') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('G') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('B') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('A') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('F') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('F') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('S') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('E') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('A') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('B') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('E') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l489
+					goto l490
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l489
+					goto l490
 				}
 				position++
 				if !_rules[ruleLocalSymbol]() {
-					goto l489
+					goto l490
 				}
-				add(ruleGOTLocation, position490)
+				add(ruleGOTLocation, position491)
 			}
 			return true
-		l489:
-			position, tokenIndex = position489, tokenIndex489
+		l490:
+			position, tokenIndex = position490, tokenIndex490
 			return false
 		},
 		/* 37 GOTAddress <- <('_' 'G' 'L' 'O' 'B' 'A' 'L' '_' 'O' 'F' 'F' 'S' 'E' 'T' '_' 'T' 'A' 'B' 'L' 'E' '_' '(' '%' 'r' 'i' 'p' ')')> */
 		func() bool {
-			position491, tokenIndex491 := position, tokenIndex
+			position492, tokenIndex492 := position, tokenIndex
 			{
-				position492 := position
+				position493 := position
 				if buffer[position] != rune('_') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('G') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('B') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('A') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('F') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('F') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('S') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('E') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('A') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('B') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('E') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('(') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('%') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('r') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('i') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune('p') {
-					goto l491
+					goto l492
 				}
 				position++
 				if buffer[position] != rune(')') {
-					goto l491
+					goto l492
 				}
 				position++
-				add(ruleGOTAddress, position492)
+				add(ruleGOTAddress, position493)
 			}
 			return true
-		l491:
-			position, tokenIndex = position491, tokenIndex491
+		l492:
+			position, tokenIndex = position492, tokenIndex492
 			return false
 		},
 		/* 38 GOTSymbolOffset <- <(('$' SymbolName ('@' 'G' 'O' 'T') ('O' 'F' 'F')?) / (':' ('g' / 'G') ('o' / 'O') ('t' / 'T') ':' SymbolName))> */
 		func() bool {
-			position493, tokenIndex493 := position, tokenIndex
+			position494, tokenIndex494 := position, tokenIndex
 			{
-				position494 := position
+				position495 := position
 				{
-					position495, tokenIndex495 := position, tokenIndex
+					position496, tokenIndex496 := position, tokenIndex
 					if buffer[position] != rune('$') {
-						goto l496
+						goto l497
 					}
 					position++
 					if !_rules[ruleSymbolName]() {
-						goto l496
+						goto l497
 					}
 					if buffer[position] != rune('@') {
-						goto l496
+						goto l497
 					}
 					position++
 					if buffer[position] != rune('G') {
-						goto l496
+						goto l497
 					}
 					position++
 					if buffer[position] != rune('O') {
-						goto l496
+						goto l497
 					}
 					position++
 					if buffer[position] != rune('T') {
-						goto l496
+						goto l497
 					}
 					position++
 					{
-						position497, tokenIndex497 := position, tokenIndex
+						position498, tokenIndex498 := position, tokenIndex
 						if buffer[position] != rune('O') {
-							goto l497
+							goto l498
 						}
 						position++
 						if buffer[position] != rune('F') {
-							goto l497
+							goto l498
 						}
 						position++
 						if buffer[position] != rune('F') {
-							goto l497
-						}
-						position++
-						goto l498
-					l497:
-						position, tokenIndex = position497, tokenIndex497
-					}
-				l498:
-					goto l495
-				l496:
-					position, tokenIndex = position495, tokenIndex495
-					if buffer[position] != rune(':') {
-						goto l493
-					}
-					position++
-					{
-						position499, tokenIndex499 := position, tokenIndex
-						if buffer[position] != rune('g') {
-							goto l500
+							goto l498
 						}
 						position++
 						goto l499
-					l500:
-						position, tokenIndex = position499, tokenIndex499
-						if buffer[position] != rune('G') {
-							goto l493
-						}
-						position++
+					l498:
+						position, tokenIndex = position498, tokenIndex498
 					}
 				l499:
-					{
-						position501, tokenIndex501 := position, tokenIndex
-						if buffer[position] != rune('o') {
-							goto l502
-						}
-						position++
-						goto l501
-					l502:
-						position, tokenIndex = position501, tokenIndex501
-						if buffer[position] != rune('O') {
-							goto l493
-						}
-						position++
-					}
-				l501:
-					{
-						position503, tokenIndex503 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l504
-						}
-						position++
-						goto l503
-					l504:
-						position, tokenIndex = position503, tokenIndex503
-						if buffer[position] != rune('T') {
-							goto l493
-						}
-						position++
-					}
-				l503:
+					goto l496
+				l497:
+					position, tokenIndex = position496, tokenIndex496
 					if buffer[position] != rune(':') {
-						goto l493
+						goto l494
+					}
+					position++
+					{
+						position500, tokenIndex500 := position, tokenIndex
+						if buffer[position] != rune('g') {
+							goto l501
+						}
+						position++
+						goto l500
+					l501:
+						position, tokenIndex = position500, tokenIndex500
+						if buffer[position] != rune('G') {
+							goto l494
+						}
+						position++
+					}
+				l500:
+					{
+						position502, tokenIndex502 := position, tokenIndex
+						if buffer[position] != rune('o') {
+							goto l503
+						}
+						position++
+						goto l502
+					l503:
+						position, tokenIndex = position502, tokenIndex502
+						if buffer[position] != rune('O') {
+							goto l494
+						}
+						position++
+					}
+				l502:
+					{
+						position504, tokenIndex504 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l505
+						}
+						position++
+						goto l504
+					l505:
+						position, tokenIndex = position504, tokenIndex504
+						if buffer[position] != rune('T') {
+							goto l494
+						}
+						position++
+					}
+				l504:
+					if buffer[position] != rune(':') {
+						goto l494
 					}
 					position++
 					if !_rules[ruleSymbolName]() {
-						goto l493
+						goto l494
 					}
 				}
-			l495:
-				add(ruleGOTSymbolOffset, position494)
+			l496:
+				add(ruleGOTSymbolOffset, position495)
 			}
 			return true
-		l493:
-			position, tokenIndex = position493, tokenIndex493
+		l494:
+			position, tokenIndex = position494, tokenIndex494
 			return false
 		},
 		/* 39 AVX512Token <- <(WS? '{' '%'? ([0-9] / [a-z])* '}')> */
 		func() bool {
-			position505, tokenIndex505 := position, tokenIndex
+			position506, tokenIndex506 := position, tokenIndex
 			{
-				position506 := position
+				position507 := position
 				{
-					position507, tokenIndex507 := position, tokenIndex
+					position508, tokenIndex508 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l507
+						goto l508
 					}
-					goto l508
-				l507:
-					position, tokenIndex = position507, tokenIndex507
+					goto l509
+				l508:
+					position, tokenIndex = position508, tokenIndex508
 				}
-			l508:
+			l509:
 				if buffer[position] != rune('{') {
-					goto l505
+					goto l506
 				}
 				position++
 				{
-					position509, tokenIndex509 := position, tokenIndex
+					position510, tokenIndex510 := position, tokenIndex
 					if buffer[position] != rune('%') {
-						goto l509
+						goto l510
 					}
 					position++
-					goto l510
-				l509:
-					position, tokenIndex = position509, tokenIndex509
-				}
-			l510:
-			l511:
-				{
-					position512, tokenIndex512 := position, tokenIndex
-					{
-						position513, tokenIndex513 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l514
-						}
-						position++
-						goto l513
-					l514:
-						position, tokenIndex = position513, tokenIndex513
-						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l512
-						}
-						position++
-					}
-				l513:
 					goto l511
-				l512:
-					position, tokenIndex = position512, tokenIndex512
+				l510:
+					position, tokenIndex = position510, tokenIndex510
 				}
-				if buffer[position] != rune('}') {
-					goto l505
-				}
-				position++
-				add(ruleAVX512Token, position506)
-			}
-			return true
-		l505:
-			position, tokenIndex = position505, tokenIndex505
-			return false
-		},
-		/* 40 TOCRefHigh <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('h' / 'H') ('a' / 'A')))> */
-		func() bool {
-			position515, tokenIndex515 := position, tokenIndex
-			{
-				position516 := position
-				if buffer[position] != rune('.') {
-					goto l515
-				}
-				position++
-				if buffer[position] != rune('T') {
-					goto l515
-				}
-				position++
-				if buffer[position] != rune('O') {
-					goto l515
-				}
-				position++
-				if buffer[position] != rune('C') {
-					goto l515
-				}
-				position++
-				if buffer[position] != rune('.') {
-					goto l515
-				}
-				position++
-				if buffer[position] != rune('-') {
-					goto l515
-				}
-				position++
+			l511:
+			l512:
 				{
-					position517, tokenIndex517 := position, tokenIndex
-					if buffer[position] != rune('0') {
-						goto l518
-					}
-					position++
-					if buffer[position] != rune('b') {
-						goto l518
-					}
-					position++
-					goto l517
-				l518:
-					position, tokenIndex = position517, tokenIndex517
-					if buffer[position] != rune('.') {
-						goto l515
-					}
-					position++
-					if buffer[position] != rune('L') {
-						goto l515
-					}
-					position++
+					position513, tokenIndex513 := position, tokenIndex
 					{
-						position521, tokenIndex521 := position, tokenIndex
-						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l522
-						}
-						position++
-						goto l521
-					l522:
-						position, tokenIndex = position521, tokenIndex521
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l523
-						}
-						position++
-						goto l521
-					l523:
-						position, tokenIndex = position521, tokenIndex521
-						if buffer[position] != rune('_') {
-							goto l524
-						}
-						position++
-						goto l521
-					l524:
-						position, tokenIndex = position521, tokenIndex521
+						position514, tokenIndex514 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
 							goto l515
 						}
 						position++
-					}
-				l521:
-				l519:
-					{
-						position520, tokenIndex520 := position, tokenIndex
-						{
-							position525, tokenIndex525 := position, tokenIndex
-							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l526
-							}
-							position++
-							goto l525
-						l526:
-							position, tokenIndex = position525, tokenIndex525
-							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l527
-							}
-							position++
-							goto l525
-						l527:
-							position, tokenIndex = position525, tokenIndex525
-							if buffer[position] != rune('_') {
-								goto l528
-							}
-							position++
-							goto l525
-						l528:
-							position, tokenIndex = position525, tokenIndex525
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l520
-							}
-							position++
+						goto l514
+					l515:
+						position, tokenIndex = position514, tokenIndex514
+						if c := buffer[position]; c < rune('a') || c > rune('z') {
+							goto l513
 						}
-					l525:
-						goto l519
-					l520:
-						position, tokenIndex = position520, tokenIndex520
+						position++
 					}
+				l514:
+					goto l512
+				l513:
+					position, tokenIndex = position513, tokenIndex513
 				}
-			l517:
-				if buffer[position] != rune('@') {
-					goto l515
+				if buffer[position] != rune('}') {
+					goto l506
+				}
+				position++
+				add(ruleAVX512Token, position507)
+			}
+			return true
+		l506:
+			position, tokenIndex = position506, tokenIndex506
+			return false
+		},
+		/* 40 TOCRefHigh <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('h' / 'H') ('a' / 'A')))> */
+		func() bool {
+			position516, tokenIndex516 := position, tokenIndex
+			{
+				position517 := position
+				if buffer[position] != rune('.') {
+					goto l516
+				}
+				position++
+				if buffer[position] != rune('T') {
+					goto l516
+				}
+				position++
+				if buffer[position] != rune('O') {
+					goto l516
+				}
+				position++
+				if buffer[position] != rune('C') {
+					goto l516
+				}
+				position++
+				if buffer[position] != rune('.') {
+					goto l516
+				}
+				position++
+				if buffer[position] != rune('-') {
+					goto l516
 				}
 				position++
 				{
-					position529, tokenIndex529 := position, tokenIndex
-					if buffer[position] != rune('h') {
-						goto l530
+					position518, tokenIndex518 := position, tokenIndex
+					if buffer[position] != rune('0') {
+						goto l519
 					}
 					position++
-					goto l529
-				l530:
-					position, tokenIndex = position529, tokenIndex529
-					if buffer[position] != rune('H') {
-						goto l515
+					if buffer[position] != rune('b') {
+						goto l519
 					}
 					position++
+					goto l518
+				l519:
+					position, tokenIndex = position518, tokenIndex518
+					if buffer[position] != rune('.') {
+						goto l516
+					}
+					position++
+					if buffer[position] != rune('L') {
+						goto l516
+					}
+					position++
+					{
+						position522, tokenIndex522 := position, tokenIndex
+						if c := buffer[position]; c < rune('a') || c > rune('z') {
+							goto l523
+						}
+						position++
+						goto l522
+					l523:
+						position, tokenIndex = position522, tokenIndex522
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
+							goto l524
+						}
+						position++
+						goto l522
+					l524:
+						position, tokenIndex = position522, tokenIndex522
+						if buffer[position] != rune('_') {
+							goto l525
+						}
+						position++
+						goto l522
+					l525:
+						position, tokenIndex = position522, tokenIndex522
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l516
+						}
+						position++
+					}
+				l522:
+				l520:
+					{
+						position521, tokenIndex521 := position, tokenIndex
+						{
+							position526, tokenIndex526 := position, tokenIndex
+							if c := buffer[position]; c < rune('a') || c > rune('z') {
+								goto l527
+							}
+							position++
+							goto l526
+						l527:
+							position, tokenIndex = position526, tokenIndex526
+							if c := buffer[position]; c < rune('A') || c > rune('Z') {
+								goto l528
+							}
+							position++
+							goto l526
+						l528:
+							position, tokenIndex = position526, tokenIndex526
+							if buffer[position] != rune('_') {
+								goto l529
+							}
+							position++
+							goto l526
+						l529:
+							position, tokenIndex = position526, tokenIndex526
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l521
+							}
+							position++
+						}
+					l526:
+						goto l520
+					l521:
+						position, tokenIndex = position521, tokenIndex521
+					}
 				}
-			l529:
+			l518:
+				if buffer[position] != rune('@') {
+					goto l516
+				}
+				position++
 				{
-					position531, tokenIndex531 := position, tokenIndex
-					if buffer[position] != rune('a') {
-						goto l532
+					position530, tokenIndex530 := position, tokenIndex
+					if buffer[position] != rune('h') {
+						goto l531
 					}
 					position++
-					goto l531
-				l532:
-					position, tokenIndex = position531, tokenIndex531
-					if buffer[position] != rune('A') {
-						goto l515
+					goto l530
+				l531:
+					position, tokenIndex = position530, tokenIndex530
+					if buffer[position] != rune('H') {
+						goto l516
 					}
 					position++
 				}
-			l531:
-				add(ruleTOCRefHigh, position516)
+			l530:
+				{
+					position532, tokenIndex532 := position, tokenIndex
+					if buffer[position] != rune('a') {
+						goto l533
+					}
+					position++
+					goto l532
+				l533:
+					position, tokenIndex = position532, tokenIndex532
+					if buffer[position] != rune('A') {
+						goto l516
+					}
+					position++
+				}
+			l532:
+				add(ruleTOCRefHigh, position517)
 			}
 			return true
-		l515:
-			position, tokenIndex = position515, tokenIndex515
+		l516:
+			position, tokenIndex = position516, tokenIndex516
 			return false
 		},
 		/* 41 TOCRefLow <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('l' / 'L')))> */
 		func() bool {
-			position533, tokenIndex533 := position, tokenIndex
+			position534, tokenIndex534 := position, tokenIndex
 			{
-				position534 := position
+				position535 := position
 				if buffer[position] != rune('.') {
-					goto l533
+					goto l534
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l533
+					goto l534
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l533
+					goto l534
 				}
 				position++
 				if buffer[position] != rune('C') {
-					goto l533
+					goto l534
 				}
 				position++
 				if buffer[position] != rune('.') {
-					goto l533
+					goto l534
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l533
+					goto l534
 				}
 				position++
 				{
-					position535, tokenIndex535 := position, tokenIndex
+					position536, tokenIndex536 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l536
+						goto l537
 					}
 					position++
 					if buffer[position] != rune('b') {
-						goto l536
+						goto l537
 					}
 					position++
-					goto l535
-				l536:
-					position, tokenIndex = position535, tokenIndex535
+					goto l536
+				l537:
+					position, tokenIndex = position536, tokenIndex536
 					if buffer[position] != rune('.') {
-						goto l533
+						goto l534
 					}
 					position++
 					if buffer[position] != rune('L') {
-						goto l533
+						goto l534
 					}
 					position++
 					{
-						position539, tokenIndex539 := position, tokenIndex
+						position540, tokenIndex540 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l540
-						}
-						position++
-						goto l539
-					l540:
-						position, tokenIndex = position539, tokenIndex539
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l541
 						}
 						position++
-						goto l539
+						goto l540
 					l541:
-						position, tokenIndex = position539, tokenIndex539
-						if buffer[position] != rune('_') {
+						position, tokenIndex = position540, tokenIndex540
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l542
 						}
 						position++
-						goto l539
+						goto l540
 					l542:
-						position, tokenIndex = position539, tokenIndex539
+						position, tokenIndex = position540, tokenIndex540
+						if buffer[position] != rune('_') {
+							goto l543
+						}
+						position++
+						goto l540
+					l543:
+						position, tokenIndex = position540, tokenIndex540
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l533
+							goto l534
 						}
 						position++
 					}
-				l539:
-				l537:
+				l540:
+				l538:
 					{
-						position538, tokenIndex538 := position, tokenIndex
+						position539, tokenIndex539 := position, tokenIndex
 						{
-							position543, tokenIndex543 := position, tokenIndex
+							position544, tokenIndex544 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l544
-							}
-							position++
-							goto l543
-						l544:
-							position, tokenIndex = position543, tokenIndex543
-							if c := buffer[position]; c < rune('A') || c > rune('Z') {
 								goto l545
 							}
 							position++
-							goto l543
+							goto l544
 						l545:
-							position, tokenIndex = position543, tokenIndex543
-							if buffer[position] != rune('_') {
+							position, tokenIndex = position544, tokenIndex544
+							if c := buffer[position]; c < rune('A') || c > rune('Z') {
 								goto l546
 							}
 							position++
-							goto l543
+							goto l544
 						l546:
-							position, tokenIndex = position543, tokenIndex543
+							position, tokenIndex = position544, tokenIndex544
+							if buffer[position] != rune('_') {
+								goto l547
+							}
+							position++
+							goto l544
+						l547:
+							position, tokenIndex = position544, tokenIndex544
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l538
+								goto l539
 							}
 							position++
 						}
-					l543:
-						goto l537
-					l538:
-						position, tokenIndex = position538, tokenIndex538
+					l544:
+						goto l538
+					l539:
+						position, tokenIndex = position539, tokenIndex539
 					}
 				}
-			l535:
+			l536:
 				if buffer[position] != rune('@') {
-					goto l533
+					goto l534
 				}
 				position++
 				{
-					position547, tokenIndex547 := position, tokenIndex
+					position548, tokenIndex548 := position, tokenIndex
 					if buffer[position] != rune('l') {
-						goto l548
+						goto l549
 					}
 					position++
-					goto l547
-				l548:
-					position, tokenIndex = position547, tokenIndex547
+					goto l548
+				l549:
+					position, tokenIndex = position548, tokenIndex548
 					if buffer[position] != rune('L') {
-						goto l533
+						goto l534
 					}
 					position++
 				}
-			l547:
-				add(ruleTOCRefLow, position534)
+			l548:
+				add(ruleTOCRefLow, position535)
 			}
 			return true
-		l533:
-			position, tokenIndex = position533, tokenIndex533
+		l534:
+			position, tokenIndex = position534, tokenIndex534
 			return false
 		},
 		/* 42 IndirectionIndicator <- <'*'> */
 		func() bool {
-			position549, tokenIndex549 := position, tokenIndex
+			position550, tokenIndex550 := position, tokenIndex
 			{
-				position550 := position
+				position551 := position
 				if buffer[position] != rune('*') {
-					goto l549
+					goto l550
 				}
 				position++
-				add(ruleIndirectionIndicator, position550)
+				add(ruleIndirectionIndicator, position551)
 			}
 			return true
-		l549:
-			position, tokenIndex = position549, tokenIndex549
+		l550:
+			position, tokenIndex = position550, tokenIndex550
 			return false
 		},
 		/* 43 Float <- <([0-9]+ '.' [0-9]*)> */
 		func() bool {
-			position551, tokenIndex551 := position, tokenIndex
+			position552, tokenIndex552 := position, tokenIndex
 			{
-				position552 := position
+				position553 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l551
+					goto l552
 				}
 				position++
-			l553:
+			l554:
 				{
-					position554, tokenIndex554 := position, tokenIndex
+					position555, tokenIndex555 := position, tokenIndex
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l554
+						goto l555
 					}
 					position++
-					goto l553
-				l554:
-					position, tokenIndex = position554, tokenIndex554
+					goto l554
+				l555:
+					position, tokenIndex = position555, tokenIndex555
 				}
 				if buffer[position] != rune('.') {
-					goto l551
+					goto l552
 				}
 				position++
-			l555:
+			l556:
 				{
-					position556, tokenIndex556 := position, tokenIndex
+					position557, tokenIndex557 := position, tokenIndex
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l556
+						goto l557
 					}
 					position++
-					goto l555
-				l556:
-					position, tokenIndex = position556, tokenIndex556
+					goto l556
+				l557:
+					position, tokenIndex = position557, tokenIndex557
 				}
-				add(ruleFloat, position552)
+				add(ruleFloat, position553)
 			}
 			return true
-		l551:
-			position, tokenIndex = position551, tokenIndex551
+		l552:
+			position, tokenIndex = position552, tokenIndex552
 			return false
 		},
 		/* 44 RegisterOrConstant <- <((('%' ([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))*) / ('$'? ((Offset Offset) / Offset)) / ('#' Float) / ('#' Offset ('*' [0-9]+ ('-' [0-9] [0-9]*)?)?) / ('#' '~'? '(' [0-9] WS? ('<' '<') WS? [0-9] ')') / ARMRegister) !('f' / 'b' / ':' / '(' / '+' / '-'))> */
 		func() bool {
-			position557, tokenIndex557 := position, tokenIndex
+			position558, tokenIndex558 := position, tokenIndex
 			{
-				position558 := position
+				position559 := position
 				{
-					position559, tokenIndex559 := position, tokenIndex
+					position560, tokenIndex560 := position, tokenIndex
 					if buffer[position] != rune('%') {
-						goto l560
+						goto l561
 					}
 					position++
 					{
-						position561, tokenIndex561 := position, tokenIndex
+						position562, tokenIndex562 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l562
+							goto l563
 						}
 						position++
-						goto l561
-					l562:
-						position, tokenIndex = position561, tokenIndex561
+						goto l562
+					l563:
+						position, tokenIndex = position562, tokenIndex562
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l560
+							goto l561
 						}
 						position++
 					}
-				l561:
-				l563:
+				l562:
+				l564:
 					{
-						position564, tokenIndex564 := position, tokenIndex
+						position565, tokenIndex565 := position, tokenIndex
 						{
-							position565, tokenIndex565 := position, tokenIndex
+							position566, tokenIndex566 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l566
-							}
-							position++
-							goto l565
-						l566:
-							position, tokenIndex = position565, tokenIndex565
-							if c := buffer[position]; c < rune('A') || c > rune('Z') {
 								goto l567
 							}
 							position++
-							goto l565
+							goto l566
 						l567:
-							position, tokenIndex = position565, tokenIndex565
+							position, tokenIndex = position566, tokenIndex566
+							if c := buffer[position]; c < rune('A') || c > rune('Z') {
+								goto l568
+							}
+							position++
+							goto l566
+						l568:
+							position, tokenIndex = position566, tokenIndex566
 							{
-								position568, tokenIndex568 := position, tokenIndex
+								position569, tokenIndex569 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l569
+									goto l570
 								}
 								position++
-								goto l568
-							l569:
-								position, tokenIndex = position568, tokenIndex568
+								goto l569
+							l570:
+								position, tokenIndex = position569, tokenIndex569
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l564
+									goto l565
 								}
 								position++
 							}
-						l568:
+						l569:
 						}
+					l566:
+						goto l564
 					l565:
-						goto l563
-					l564:
-						position, tokenIndex = position564, tokenIndex564
+						position, tokenIndex = position565, tokenIndex565
 					}
-					goto l559
-				l560:
-					position, tokenIndex = position559, tokenIndex559
+					goto l560
+				l561:
+					position, tokenIndex = position560, tokenIndex560
 					{
-						position571, tokenIndex571 := position, tokenIndex
+						position572, tokenIndex572 := position, tokenIndex
 						if buffer[position] != rune('$') {
-							goto l571
+							goto l572
 						}
 						position++
-						goto l572
-					l571:
-						position, tokenIndex = position571, tokenIndex571
-					}
-				l572:
-					{
-						position573, tokenIndex573 := position, tokenIndex
-						if !_rules[ruleOffset]() {
-							goto l574
-						}
-						if !_rules[ruleOffset]() {
-							goto l574
-						}
 						goto l573
-					l574:
-						position, tokenIndex = position573, tokenIndex573
-						if !_rules[ruleOffset]() {
-							goto l570
-						}
+					l572:
+						position, tokenIndex = position572, tokenIndex572
 					}
 				l573:
-					goto l559
-				l570:
-					position, tokenIndex = position559, tokenIndex559
+					{
+						position574, tokenIndex574 := position, tokenIndex
+						if !_rules[ruleOffset]() {
+							goto l575
+						}
+						if !_rules[ruleOffset]() {
+							goto l575
+						}
+						goto l574
+					l575:
+						position, tokenIndex = position574, tokenIndex574
+						if !_rules[ruleOffset]() {
+							goto l571
+						}
+					}
+				l574:
+					goto l560
+				l571:
+					position, tokenIndex = position560, tokenIndex560
 					if buffer[position] != rune('#') {
-						goto l575
+						goto l576
 					}
 					position++
 					if !_rules[ruleFloat]() {
-						goto l575
-					}
-					goto l559
-				l575:
-					position, tokenIndex = position559, tokenIndex559
-					if buffer[position] != rune('#') {
 						goto l576
 					}
+					goto l560
+				l576:
+					position, tokenIndex = position560, tokenIndex560
+					if buffer[position] != rune('#') {
+						goto l577
+					}
 					position++
 					if !_rules[ruleOffset]() {
-						goto l576
+						goto l577
 					}
 					{
-						position577, tokenIndex577 := position, tokenIndex
+						position578, tokenIndex578 := position, tokenIndex
 						if buffer[position] != rune('*') {
-							goto l577
+							goto l578
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l577
+							goto l578
 						}
 						position++
-					l579:
-						{
-							position580, tokenIndex580 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l580
-							}
-							position++
-							goto l579
-						l580:
-							position, tokenIndex = position580, tokenIndex580
-						}
+					l580:
 						{
 							position581, tokenIndex581 := position, tokenIndex
-							if buffer[position] != rune('-') {
-								goto l581
-							}
-							position++
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
 								goto l581
 							}
 							position++
-						l583:
-							{
-								position584, tokenIndex584 := position, tokenIndex
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l584
-								}
-								position++
-								goto l583
-							l584:
-								position, tokenIndex = position584, tokenIndex584
-							}
-							goto l582
+							goto l580
 						l581:
 							position, tokenIndex = position581, tokenIndex581
 						}
-					l582:
-						goto l578
-					l577:
-						position, tokenIndex = position577, tokenIndex577
+						{
+							position582, tokenIndex582 := position, tokenIndex
+							if buffer[position] != rune('-') {
+								goto l582
+							}
+							position++
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l582
+							}
+							position++
+						l584:
+							{
+								position585, tokenIndex585 := position, tokenIndex
+								if c := buffer[position]; c < rune('0') || c > rune('9') {
+									goto l585
+								}
+								position++
+								goto l584
+							l585:
+								position, tokenIndex = position585, tokenIndex585
+							}
+							goto l583
+						l582:
+							position, tokenIndex = position582, tokenIndex582
+						}
+					l583:
+						goto l579
+					l578:
+						position, tokenIndex = position578, tokenIndex578
 					}
-				l578:
-					goto l559
-				l576:
-					position, tokenIndex = position559, tokenIndex559
+				l579:
+					goto l560
+				l577:
+					position, tokenIndex = position560, tokenIndex560
 					if buffer[position] != rune('#') {
-						goto l585
+						goto l586
 					}
 					position++
 					{
-						position586, tokenIndex586 := position, tokenIndex
+						position587, tokenIndex587 := position, tokenIndex
 						if buffer[position] != rune('~') {
-							goto l586
+							goto l587
 						}
 						position++
-						goto l587
-					l586:
-						position, tokenIndex = position586, tokenIndex586
+						goto l588
+					l587:
+						position, tokenIndex = position587, tokenIndex587
 					}
-				l587:
+				l588:
 					if buffer[position] != rune('(') {
-						goto l585
+						goto l586
 					}
 					position++
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l585
+						goto l586
 					}
 					position++
 					{
-						position588, tokenIndex588 := position, tokenIndex
+						position589, tokenIndex589 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l588
+							goto l589
 						}
-						goto l589
-					l588:
-						position, tokenIndex = position588, tokenIndex588
+						goto l590
+					l589:
+						position, tokenIndex = position589, tokenIndex589
 					}
-				l589:
+				l590:
 					if buffer[position] != rune('<') {
-						goto l585
+						goto l586
 					}
 					position++
 					if buffer[position] != rune('<') {
-						goto l585
+						goto l586
 					}
 					position++
 					{
-						position590, tokenIndex590 := position, tokenIndex
+						position591, tokenIndex591 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l590
+							goto l591
 						}
-						goto l591
-					l590:
-						position, tokenIndex = position590, tokenIndex590
+						goto l592
+					l591:
+						position, tokenIndex = position591, tokenIndex591
 					}
-				l591:
+				l592:
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l585
+						goto l586
 					}
 					position++
 					if buffer[position] != rune(')') {
-						goto l585
+						goto l586
 					}
 					position++
-					goto l559
-				l585:
-					position, tokenIndex = position559, tokenIndex559
+					goto l560
+				l586:
+					position, tokenIndex = position560, tokenIndex560
 					if !_rules[ruleARMRegister]() {
-						goto l557
+						goto l558
 					}
 				}
-			l559:
+			l560:
 				{
-					position592, tokenIndex592 := position, tokenIndex
+					position593, tokenIndex593 := position, tokenIndex
 					{
-						position593, tokenIndex593 := position, tokenIndex
+						position594, tokenIndex594 := position, tokenIndex
 						if buffer[position] != rune('f') {
-							goto l594
-						}
-						position++
-						goto l593
-					l594:
-						position, tokenIndex = position593, tokenIndex593
-						if buffer[position] != rune('b') {
 							goto l595
 						}
 						position++
-						goto l593
+						goto l594
 					l595:
-						position, tokenIndex = position593, tokenIndex593
-						if buffer[position] != rune(':') {
+						position, tokenIndex = position594, tokenIndex594
+						if buffer[position] != rune('b') {
 							goto l596
 						}
 						position++
-						goto l593
+						goto l594
 					l596:
-						position, tokenIndex = position593, tokenIndex593
-						if buffer[position] != rune('(') {
+						position, tokenIndex = position594, tokenIndex594
+						if buffer[position] != rune(':') {
 							goto l597
 						}
 						position++
-						goto l593
+						goto l594
 					l597:
-						position, tokenIndex = position593, tokenIndex593
-						if buffer[position] != rune('+') {
+						position, tokenIndex = position594, tokenIndex594
+						if buffer[position] != rune('(') {
 							goto l598
 						}
 						position++
-						goto l593
+						goto l594
 					l598:
-						position, tokenIndex = position593, tokenIndex593
+						position, tokenIndex = position594, tokenIndex594
+						if buffer[position] != rune('+') {
+							goto l599
+						}
+						position++
+						goto l594
+					l599:
+						position, tokenIndex = position594, tokenIndex594
 						if buffer[position] != rune('-') {
-							goto l592
+							goto l593
 						}
 						position++
 					}
+				l594:
+					goto l558
 				l593:
-					goto l557
-				l592:
-					position, tokenIndex = position592, tokenIndex592
+					position, tokenIndex = position593, tokenIndex593
 				}
-				add(ruleRegisterOrConstant, position558)
+				add(ruleRegisterOrConstant, position559)
 			}
 			return true
-		l557:
-			position, tokenIndex = position557, tokenIndex557
+		l558:
+			position, tokenIndex = position558, tokenIndex558
 			return false
 		},
 		/* 45 ARMConstantTweak <- <((((('u' / 's') (('x' / 'X') ('t' / 'T')) ('x' / 'w' / 'h' / 'b')) / (('l' / 'L') ('s' / 'S') ('l' / 'L')) / (('l' / 'L') ('s' / 'S') ('r' / 'R')) / (('r' / 'R') ('o' / 'O') ('r' / 'R')) / (('a' / 'A') ('s' / 'S') ('r' / 'R'))) (WS '#' Offset)?) / (('m' / 'M') ('u' / 'U') ('l' / 'L') ' ' ('v' / 'V') ('l' / 'L')) / (('m' / 'M') ('u' / 'U') ('l' / 'L') ' ' '#' [0-9]))> */
 		func() bool {
-			position599, tokenIndex599 := position, tokenIndex
+			position600, tokenIndex600 := position, tokenIndex
 			{
-				position600 := position
+				position601 := position
 				{
-					position601, tokenIndex601 := position, tokenIndex
+					position602, tokenIndex602 := position, tokenIndex
 					{
-						position603, tokenIndex603 := position, tokenIndex
+						position604, tokenIndex604 := position, tokenIndex
 						{
-							position605, tokenIndex605 := position, tokenIndex
+							position606, tokenIndex606 := position, tokenIndex
 							if buffer[position] != rune('u') {
-								goto l606
+								goto l607
 							}
 							position++
-							goto l605
-						l606:
-							position, tokenIndex = position605, tokenIndex605
+							goto l606
+						l607:
+							position, tokenIndex = position606, tokenIndex606
 							if buffer[position] != rune('s') {
-								goto l604
+								goto l605
 							}
 							position++
 						}
-					l605:
+					l606:
 						{
-							position607, tokenIndex607 := position, tokenIndex
+							position608, tokenIndex608 := position, tokenIndex
 							if buffer[position] != rune('x') {
-								goto l608
+								goto l609
 							}
 							position++
-							goto l607
-						l608:
-							position, tokenIndex = position607, tokenIndex607
+							goto l608
+						l609:
+							position, tokenIndex = position608, tokenIndex608
 							if buffer[position] != rune('X') {
-								goto l604
+								goto l605
 							}
 							position++
 						}
-					l607:
+					l608:
 						{
-							position609, tokenIndex609 := position, tokenIndex
+							position610, tokenIndex610 := position, tokenIndex
 							if buffer[position] != rune('t') {
-								goto l610
+								goto l611
 							}
 							position++
-							goto l609
-						l610:
-							position, tokenIndex = position609, tokenIndex609
+							goto l610
+						l611:
+							position, tokenIndex = position610, tokenIndex610
 							if buffer[position] != rune('T') {
-								goto l604
+								goto l605
 							}
 							position++
 						}
-					l609:
+					l610:
 						{
-							position611, tokenIndex611 := position, tokenIndex
+							position612, tokenIndex612 := position, tokenIndex
 							if buffer[position] != rune('x') {
-								goto l612
-							}
-							position++
-							goto l611
-						l612:
-							position, tokenIndex = position611, tokenIndex611
-							if buffer[position] != rune('w') {
 								goto l613
 							}
 							position++
-							goto l611
+							goto l612
 						l613:
-							position, tokenIndex = position611, tokenIndex611
-							if buffer[position] != rune('h') {
+							position, tokenIndex = position612, tokenIndex612
+							if buffer[position] != rune('w') {
 								goto l614
 							}
 							position++
-							goto l611
+							goto l612
 						l614:
-							position, tokenIndex = position611, tokenIndex611
+							position, tokenIndex = position612, tokenIndex612
+							if buffer[position] != rune('h') {
+								goto l615
+							}
+							position++
+							goto l612
+						l615:
+							position, tokenIndex = position612, tokenIndex612
 							if buffer[position] != rune('b') {
-								goto l604
+								goto l605
 							}
 							position++
 						}
-					l611:
-						goto l603
-					l604:
-						position, tokenIndex = position603, tokenIndex603
+					l612:
+						goto l604
+					l605:
+						position, tokenIndex = position604, tokenIndex604
 						{
-							position616, tokenIndex616 := position, tokenIndex
+							position617, tokenIndex617 := position, tokenIndex
 							if buffer[position] != rune('l') {
-								goto l617
+								goto l618
 							}
 							position++
-							goto l616
-						l617:
-							position, tokenIndex = position616, tokenIndex616
+							goto l617
+						l618:
+							position, tokenIndex = position617, tokenIndex617
 							if buffer[position] != rune('L') {
-								goto l615
+								goto l616
 							}
 							position++
 						}
+					l617:
+						{
+							position619, tokenIndex619 := position, tokenIndex
+							if buffer[position] != rune('s') {
+								goto l620
+							}
+							position++
+							goto l619
+						l620:
+							position, tokenIndex = position619, tokenIndex619
+							if buffer[position] != rune('S') {
+								goto l616
+							}
+							position++
+						}
+					l619:
+						{
+							position621, tokenIndex621 := position, tokenIndex
+							if buffer[position] != rune('l') {
+								goto l622
+							}
+							position++
+							goto l621
+						l622:
+							position, tokenIndex = position621, tokenIndex621
+							if buffer[position] != rune('L') {
+								goto l616
+							}
+							position++
+						}
+					l621:
+						goto l604
 					l616:
+						position, tokenIndex = position604, tokenIndex604
 						{
-							position618, tokenIndex618 := position, tokenIndex
+							position624, tokenIndex624 := position, tokenIndex
+							if buffer[position] != rune('l') {
+								goto l625
+							}
+							position++
+							goto l624
+						l625:
+							position, tokenIndex = position624, tokenIndex624
+							if buffer[position] != rune('L') {
+								goto l623
+							}
+							position++
+						}
+					l624:
+						{
+							position626, tokenIndex626 := position, tokenIndex
 							if buffer[position] != rune('s') {
-								goto l619
+								goto l627
 							}
 							position++
-							goto l618
-						l619:
-							position, tokenIndex = position618, tokenIndex618
+							goto l626
+						l627:
+							position, tokenIndex = position626, tokenIndex626
 							if buffer[position] != rune('S') {
-								goto l615
+								goto l623
 							}
 							position++
 						}
-					l618:
+					l626:
 						{
-							position620, tokenIndex620 := position, tokenIndex
-							if buffer[position] != rune('l') {
-								goto l621
+							position628, tokenIndex628 := position, tokenIndex
+							if buffer[position] != rune('r') {
+								goto l629
 							}
 							position++
-							goto l620
-						l621:
-							position, tokenIndex = position620, tokenIndex620
-							if buffer[position] != rune('L') {
-								goto l615
+							goto l628
+						l629:
+							position, tokenIndex = position628, tokenIndex628
+							if buffer[position] != rune('R') {
+								goto l623
 							}
 							position++
 						}
-					l620:
-						goto l603
-					l615:
-						position, tokenIndex = position603, tokenIndex603
-						{
-							position623, tokenIndex623 := position, tokenIndex
-							if buffer[position] != rune('l') {
-								goto l624
-							}
-							position++
-							goto l623
-						l624:
-							position, tokenIndex = position623, tokenIndex623
-							if buffer[position] != rune('L') {
-								goto l622
-							}
-							position++
-						}
+					l628:
+						goto l604
 					l623:
+						position, tokenIndex = position604, tokenIndex604
 						{
-							position625, tokenIndex625 := position, tokenIndex
-							if buffer[position] != rune('s') {
-								goto l626
-							}
-							position++
-							goto l625
-						l626:
-							position, tokenIndex = position625, tokenIndex625
-							if buffer[position] != rune('S') {
-								goto l622
-							}
-							position++
-						}
-					l625:
-						{
-							position627, tokenIndex627 := position, tokenIndex
+							position631, tokenIndex631 := position, tokenIndex
 							if buffer[position] != rune('r') {
-								goto l628
+								goto l632
 							}
 							position++
-							goto l627
-						l628:
-							position, tokenIndex = position627, tokenIndex627
+							goto l631
+						l632:
+							position, tokenIndex = position631, tokenIndex631
 							if buffer[position] != rune('R') {
-								goto l622
+								goto l630
 							}
 							position++
 						}
-					l627:
-						goto l603
-					l622:
-						position, tokenIndex = position603, tokenIndex603
+					l631:
 						{
-							position630, tokenIndex630 := position, tokenIndex
-							if buffer[position] != rune('r') {
-								goto l631
-							}
-							position++
-							goto l630
-						l631:
-							position, tokenIndex = position630, tokenIndex630
-							if buffer[position] != rune('R') {
-								goto l629
-							}
-							position++
-						}
-					l630:
-						{
-							position632, tokenIndex632 := position, tokenIndex
+							position633, tokenIndex633 := position, tokenIndex
 							if buffer[position] != rune('o') {
-								goto l633
+								goto l634
 							}
 							position++
-							goto l632
-						l633:
-							position, tokenIndex = position632, tokenIndex632
+							goto l633
+						l634:
+							position, tokenIndex = position633, tokenIndex633
 							if buffer[position] != rune('O') {
-								goto l629
+								goto l630
 							}
 							position++
 						}
-					l632:
+					l633:
 						{
-							position634, tokenIndex634 := position, tokenIndex
+							position635, tokenIndex635 := position, tokenIndex
 							if buffer[position] != rune('r') {
-								goto l635
+								goto l636
 							}
 							position++
-							goto l634
-						l635:
-							position, tokenIndex = position634, tokenIndex634
+							goto l635
+						l636:
+							position, tokenIndex = position635, tokenIndex635
 							if buffer[position] != rune('R') {
-								goto l629
+								goto l630
 							}
 							position++
 						}
-					l634:
-						goto l603
-					l629:
-						position, tokenIndex = position603, tokenIndex603
+					l635:
+						goto l604
+					l630:
+						position, tokenIndex = position604, tokenIndex604
 						{
-							position636, tokenIndex636 := position, tokenIndex
+							position637, tokenIndex637 := position, tokenIndex
 							if buffer[position] != rune('a') {
-								goto l637
+								goto l638
 							}
 							position++
-							goto l636
-						l637:
-							position, tokenIndex = position636, tokenIndex636
+							goto l637
+						l638:
+							position, tokenIndex = position637, tokenIndex637
 							if buffer[position] != rune('A') {
-								goto l602
+								goto l603
 							}
 							position++
 						}
-					l636:
+					l637:
 						{
-							position638, tokenIndex638 := position, tokenIndex
+							position639, tokenIndex639 := position, tokenIndex
 							if buffer[position] != rune('s') {
-								goto l639
+								goto l640
 							}
 							position++
-							goto l638
-						l639:
-							position, tokenIndex = position638, tokenIndex638
+							goto l639
+						l640:
+							position, tokenIndex = position639, tokenIndex639
 							if buffer[position] != rune('S') {
-								goto l602
+								goto l603
 							}
 							position++
 						}
-					l638:
+					l639:
 						{
-							position640, tokenIndex640 := position, tokenIndex
+							position641, tokenIndex641 := position, tokenIndex
 							if buffer[position] != rune('r') {
-								goto l641
+								goto l642
 							}
 							position++
-							goto l640
-						l641:
-							position, tokenIndex = position640, tokenIndex640
+							goto l641
+						l642:
+							position, tokenIndex = position641, tokenIndex641
 							if buffer[position] != rune('R') {
-								goto l602
+								goto l603
 							}
 							position++
 						}
-					l640:
+					l641:
 					}
-				l603:
+				l604:
 					{
-						position642, tokenIndex642 := position, tokenIndex
+						position643, tokenIndex643 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l642
+							goto l643
 						}
 						if buffer[position] != rune('#') {
-							goto l642
+							goto l643
 						}
 						position++
 						if !_rules[ruleOffset]() {
-							goto l642
+							goto l643
 						}
-						goto l643
-					l642:
-						position, tokenIndex = position642, tokenIndex642
-					}
-				l643:
-					goto l601
-				l602:
-					position, tokenIndex = position601, tokenIndex601
-					{
-						position645, tokenIndex645 := position, tokenIndex
-						if buffer[position] != rune('m') {
-							goto l646
-						}
-						position++
-						goto l645
-					l646:
-						position, tokenIndex = position645, tokenIndex645
-						if buffer[position] != rune('M') {
-							goto l644
-						}
-						position++
-					}
-				l645:
-					{
-						position647, tokenIndex647 := position, tokenIndex
-						if buffer[position] != rune('u') {
-							goto l648
-						}
-						position++
-						goto l647
-					l648:
-						position, tokenIndex = position647, tokenIndex647
-						if buffer[position] != rune('U') {
-							goto l644
-						}
-						position++
-					}
-				l647:
-					{
-						position649, tokenIndex649 := position, tokenIndex
-						if buffer[position] != rune('l') {
-							goto l650
-						}
-						position++
-						goto l649
-					l650:
-						position, tokenIndex = position649, tokenIndex649
-						if buffer[position] != rune('L') {
-							goto l644
-						}
-						position++
-					}
-				l649:
-					if buffer[position] != rune(' ') {
 						goto l644
+					l643:
+						position, tokenIndex = position643, tokenIndex643
+					}
+				l644:
+					goto l602
+				l603:
+					position, tokenIndex = position602, tokenIndex602
+					{
+						position646, tokenIndex646 := position, tokenIndex
+						if buffer[position] != rune('m') {
+							goto l647
+						}
+						position++
+						goto l646
+					l647:
+						position, tokenIndex = position646, tokenIndex646
+						if buffer[position] != rune('M') {
+							goto l645
+						}
+						position++
+					}
+				l646:
+					{
+						position648, tokenIndex648 := position, tokenIndex
+						if buffer[position] != rune('u') {
+							goto l649
+						}
+						position++
+						goto l648
+					l649:
+						position, tokenIndex = position648, tokenIndex648
+						if buffer[position] != rune('U') {
+							goto l645
+						}
+						position++
+					}
+				l648:
+					{
+						position650, tokenIndex650 := position, tokenIndex
+						if buffer[position] != rune('l') {
+							goto l651
+						}
+						position++
+						goto l650
+					l651:
+						position, tokenIndex = position650, tokenIndex650
+						if buffer[position] != rune('L') {
+							goto l645
+						}
+						position++
+					}
+				l650:
+					if buffer[position] != rune(' ') {
+						goto l645
 					}
 					position++
 					{
-						position651, tokenIndex651 := position, tokenIndex
+						position652, tokenIndex652 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l652
+							goto l653
 						}
 						position++
-						goto l651
-					l652:
-						position, tokenIndex = position651, tokenIndex651
+						goto l652
+					l653:
+						position, tokenIndex = position652, tokenIndex652
 						if buffer[position] != rune('V') {
-							goto l644
+							goto l645
 						}
 						position++
 					}
-				l651:
+				l652:
 					{
-						position653, tokenIndex653 := position, tokenIndex
+						position654, tokenIndex654 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l654
+							goto l655
 						}
 						position++
-						goto l653
-					l654:
-						position, tokenIndex = position653, tokenIndex653
+						goto l654
+					l655:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('L') {
-							goto l644
+							goto l645
 						}
 						position++
 					}
-				l653:
-					goto l601
-				l644:
-					position, tokenIndex = position601, tokenIndex601
+				l654:
+					goto l602
+				l645:
+					position, tokenIndex = position602, tokenIndex602
 					{
-						position655, tokenIndex655 := position, tokenIndex
+						position656, tokenIndex656 := position, tokenIndex
 						if buffer[position] != rune('m') {
-							goto l656
+							goto l657
 						}
 						position++
-						goto l655
-					l656:
-						position, tokenIndex = position655, tokenIndex655
+						goto l656
+					l657:
+						position, tokenIndex = position656, tokenIndex656
 						if buffer[position] != rune('M') {
-							goto l599
+							goto l600
 						}
 						position++
 					}
-				l655:
+				l656:
 					{
-						position657, tokenIndex657 := position, tokenIndex
+						position658, tokenIndex658 := position, tokenIndex
 						if buffer[position] != rune('u') {
-							goto l658
+							goto l659
 						}
 						position++
-						goto l657
-					l658:
-						position, tokenIndex = position657, tokenIndex657
+						goto l658
+					l659:
+						position, tokenIndex = position658, tokenIndex658
 						if buffer[position] != rune('U') {
-							goto l599
+							goto l600
 						}
 						position++
 					}
-				l657:
+				l658:
 					{
-						position659, tokenIndex659 := position, tokenIndex
+						position660, tokenIndex660 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l660
+							goto l661
 						}
 						position++
-						goto l659
-					l660:
-						position, tokenIndex = position659, tokenIndex659
+						goto l660
+					l661:
+						position, tokenIndex = position660, tokenIndex660
 						if buffer[position] != rune('L') {
-							goto l599
+							goto l600
 						}
 						position++
 					}
-				l659:
+				l660:
 					if buffer[position] != rune(' ') {
-						goto l599
+						goto l600
 					}
 					position++
 					if buffer[position] != rune('#') {
-						goto l599
+						goto l600
 					}
 					position++
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l599
+						goto l600
 					}
 					position++
 				}
-			l601:
-				add(ruleARMConstantTweak, position600)
+			l602:
+				add(ruleARMConstantTweak, position601)
 			}
 			return true
-		l599:
-			position, tokenIndex = position599, tokenIndex599
+		l600:
+			position, tokenIndex = position600, tokenIndex600
 			return false
 		},
 		/* 46 ARMRegister <- <((('s' / 'S') ('p' / 'P')) / (('x' / 'w' / 'd' / 'q' / 's' / 'h' / 'b') [0-9] [0-9]?) / (('x' / 'X') ('z' / 'Z') ('r' / 'R')) / (('w' / 'W') ('z' / 'Z') ('r' / 'R')) / (('n' / 'N') ('z' / 'Z') ('c' / 'C') ('v' / 'V')) / SVE2PredicateRegister / ARMVectorRegister / SVE2SpecialValue / ('{' WS? ARMVectorRegister (',' WS? ARMVectorRegister)* WS? '}' ('[' [0-9] [0-9]? ']')?))> */
 		func() bool {
-			position661, tokenIndex661 := position, tokenIndex
+			position662, tokenIndex662 := position, tokenIndex
 			{
-				position662 := position
+				position663 := position
 				{
-					position663, tokenIndex663 := position, tokenIndex
+					position664, tokenIndex664 := position, tokenIndex
 					{
-						position665, tokenIndex665 := position, tokenIndex
+						position666, tokenIndex666 := position, tokenIndex
 						if buffer[position] != rune('s') {
-							goto l666
+							goto l667
 						}
 						position++
-						goto l665
-					l666:
-						position, tokenIndex = position665, tokenIndex665
+						goto l666
+					l667:
+						position, tokenIndex = position666, tokenIndex666
 						if buffer[position] != rune('S') {
-							goto l664
+							goto l665
 						}
 						position++
 					}
-				l665:
+				l666:
 					{
-						position667, tokenIndex667 := position, tokenIndex
+						position668, tokenIndex668 := position, tokenIndex
 						if buffer[position] != rune('p') {
-							goto l668
-						}
-						position++
-						goto l667
-					l668:
-						position, tokenIndex = position667, tokenIndex667
-						if buffer[position] != rune('P') {
-							goto l664
-						}
-						position++
-					}
-				l667:
-					goto l663
-				l664:
-					position, tokenIndex = position663, tokenIndex663
-					{
-						position670, tokenIndex670 := position, tokenIndex
-						if buffer[position] != rune('x') {
-							goto l671
-						}
-						position++
-						goto l670
-					l671:
-						position, tokenIndex = position670, tokenIndex670
-						if buffer[position] != rune('w') {
-							goto l672
-						}
-						position++
-						goto l670
-					l672:
-						position, tokenIndex = position670, tokenIndex670
-						if buffer[position] != rune('d') {
-							goto l673
-						}
-						position++
-						goto l670
-					l673:
-						position, tokenIndex = position670, tokenIndex670
-						if buffer[position] != rune('q') {
-							goto l674
-						}
-						position++
-						goto l670
-					l674:
-						position, tokenIndex = position670, tokenIndex670
-						if buffer[position] != rune('s') {
-							goto l675
-						}
-						position++
-						goto l670
-					l675:
-						position, tokenIndex = position670, tokenIndex670
-						if buffer[position] != rune('h') {
-							goto l676
-						}
-						position++
-						goto l670
-					l676:
-						position, tokenIndex = position670, tokenIndex670
-						if buffer[position] != rune('b') {
 							goto l669
 						}
 						position++
+						goto l668
+					l669:
+						position, tokenIndex = position668, tokenIndex668
+						if buffer[position] != rune('P') {
+							goto l665
+						}
+						position++
 					}
-				l670:
-					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l669
-					}
-					position++
+				l668:
+					goto l664
+				l665:
+					position, tokenIndex = position664, tokenIndex664
 					{
-						position677, tokenIndex677 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
+						position671, tokenIndex671 := position, tokenIndex
+						if buffer[position] != rune('x') {
+							goto l672
+						}
+						position++
+						goto l671
+					l672:
+						position, tokenIndex = position671, tokenIndex671
+						if buffer[position] != rune('w') {
+							goto l673
+						}
+						position++
+						goto l671
+					l673:
+						position, tokenIndex = position671, tokenIndex671
+						if buffer[position] != rune('d') {
+							goto l674
+						}
+						position++
+						goto l671
+					l674:
+						position, tokenIndex = position671, tokenIndex671
+						if buffer[position] != rune('q') {
+							goto l675
+						}
+						position++
+						goto l671
+					l675:
+						position, tokenIndex = position671, tokenIndex671
+						if buffer[position] != rune('s') {
+							goto l676
+						}
+						position++
+						goto l671
+					l676:
+						position, tokenIndex = position671, tokenIndex671
+						if buffer[position] != rune('h') {
 							goto l677
 						}
 						position++
-						goto l678
+						goto l671
 					l677:
-						position, tokenIndex = position677, tokenIndex677
-					}
-				l678:
-					goto l663
-				l669:
-					position, tokenIndex = position663, tokenIndex663
-					{
-						position680, tokenIndex680 := position, tokenIndex
-						if buffer[position] != rune('x') {
-							goto l681
-						}
-						position++
-						goto l680
-					l681:
-						position, tokenIndex = position680, tokenIndex680
-						if buffer[position] != rune('X') {
-							goto l679
+						position, tokenIndex = position671, tokenIndex671
+						if buffer[position] != rune('b') {
+							goto l670
 						}
 						position++
 					}
-				l680:
-					{
-						position682, tokenIndex682 := position, tokenIndex
-						if buffer[position] != rune('z') {
-							goto l683
-						}
-						position++
-						goto l682
-					l683:
-						position, tokenIndex = position682, tokenIndex682
-						if buffer[position] != rune('Z') {
-							goto l679
-						}
-						position++
-					}
-				l682:
-					{
-						position684, tokenIndex684 := position, tokenIndex
-						if buffer[position] != rune('r') {
-							goto l685
-						}
-						position++
-						goto l684
-					l685:
-						position, tokenIndex = position684, tokenIndex684
-						if buffer[position] != rune('R') {
-							goto l679
-						}
-						position++
-					}
-				l684:
-					goto l663
-				l679:
-					position, tokenIndex = position663, tokenIndex663
-					{
-						position687, tokenIndex687 := position, tokenIndex
-						if buffer[position] != rune('w') {
-							goto l688
-						}
-						position++
-						goto l687
-					l688:
-						position, tokenIndex = position687, tokenIndex687
-						if buffer[position] != rune('W') {
-							goto l686
-						}
-						position++
-					}
-				l687:
-					{
-						position689, tokenIndex689 := position, tokenIndex
-						if buffer[position] != rune('z') {
-							goto l690
-						}
-						position++
-						goto l689
-					l690:
-						position, tokenIndex = position689, tokenIndex689
-						if buffer[position] != rune('Z') {
-							goto l686
-						}
-						position++
-					}
-				l689:
-					{
-						position691, tokenIndex691 := position, tokenIndex
-						if buffer[position] != rune('r') {
-							goto l692
-						}
-						position++
-						goto l691
-					l692:
-						position, tokenIndex = position691, tokenIndex691
-						if buffer[position] != rune('R') {
-							goto l686
-						}
-						position++
-					}
-				l691:
-					goto l663
-				l686:
-					position, tokenIndex = position663, tokenIndex663
-					{
-						position694, tokenIndex694 := position, tokenIndex
-						if buffer[position] != rune('n') {
-							goto l695
-						}
-						position++
-						goto l694
-					l695:
-						position, tokenIndex = position694, tokenIndex694
-						if buffer[position] != rune('N') {
-							goto l693
-						}
-						position++
-					}
-				l694:
-					{
-						position696, tokenIndex696 := position, tokenIndex
-						if buffer[position] != rune('z') {
-							goto l697
-						}
-						position++
-						goto l696
-					l697:
-						position, tokenIndex = position696, tokenIndex696
-						if buffer[position] != rune('Z') {
-							goto l693
-						}
-						position++
-					}
-				l696:
-					{
-						position698, tokenIndex698 := position, tokenIndex
-						if buffer[position] != rune('c') {
-							goto l699
-						}
-						position++
-						goto l698
-					l699:
-						position, tokenIndex = position698, tokenIndex698
-						if buffer[position] != rune('C') {
-							goto l693
-						}
-						position++
-					}
-				l698:
-					{
-						position700, tokenIndex700 := position, tokenIndex
-						if buffer[position] != rune('v') {
-							goto l701
-						}
-						position++
-						goto l700
-					l701:
-						position, tokenIndex = position700, tokenIndex700
-						if buffer[position] != rune('V') {
-							goto l693
-						}
-						position++
-					}
-				l700:
-					goto l663
-				l693:
-					position, tokenIndex = position663, tokenIndex663
-					if !_rules[ruleSVE2PredicateRegister]() {
-						goto l702
-					}
-					goto l663
-				l702:
-					position, tokenIndex = position663, tokenIndex663
-					if !_rules[ruleARMVectorRegister]() {
-						goto l703
-					}
-					goto l663
-				l703:
-					position, tokenIndex = position663, tokenIndex663
-					if !_rules[ruleSVE2SpecialValue]() {
-						goto l704
-					}
-					goto l663
-				l704:
-					position, tokenIndex = position663, tokenIndex663
-					if buffer[position] != rune('{') {
-						goto l661
+				l671:
+					if c := buffer[position]; c < rune('0') || c > rune('9') {
+						goto l670
 					}
 					position++
 					{
-						position705, tokenIndex705 := position, tokenIndex
-						if !_rules[ruleWS]() {
-							goto l705
+						position678, tokenIndex678 := position, tokenIndex
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l678
 						}
-						goto l706
-					l705:
-						position, tokenIndex = position705, tokenIndex705
+						position++
+						goto l679
+					l678:
+						position, tokenIndex = position678, tokenIndex678
 					}
-				l706:
+				l679:
+					goto l664
+				l670:
+					position, tokenIndex = position664, tokenIndex664
+					{
+						position681, tokenIndex681 := position, tokenIndex
+						if buffer[position] != rune('x') {
+							goto l682
+						}
+						position++
+						goto l681
+					l682:
+						position, tokenIndex = position681, tokenIndex681
+						if buffer[position] != rune('X') {
+							goto l680
+						}
+						position++
+					}
+				l681:
+					{
+						position683, tokenIndex683 := position, tokenIndex
+						if buffer[position] != rune('z') {
+							goto l684
+						}
+						position++
+						goto l683
+					l684:
+						position, tokenIndex = position683, tokenIndex683
+						if buffer[position] != rune('Z') {
+							goto l680
+						}
+						position++
+					}
+				l683:
+					{
+						position685, tokenIndex685 := position, tokenIndex
+						if buffer[position] != rune('r') {
+							goto l686
+						}
+						position++
+						goto l685
+					l686:
+						position, tokenIndex = position685, tokenIndex685
+						if buffer[position] != rune('R') {
+							goto l680
+						}
+						position++
+					}
+				l685:
+					goto l664
+				l680:
+					position, tokenIndex = position664, tokenIndex664
+					{
+						position688, tokenIndex688 := position, tokenIndex
+						if buffer[position] != rune('w') {
+							goto l689
+						}
+						position++
+						goto l688
+					l689:
+						position, tokenIndex = position688, tokenIndex688
+						if buffer[position] != rune('W') {
+							goto l687
+						}
+						position++
+					}
+				l688:
+					{
+						position690, tokenIndex690 := position, tokenIndex
+						if buffer[position] != rune('z') {
+							goto l691
+						}
+						position++
+						goto l690
+					l691:
+						position, tokenIndex = position690, tokenIndex690
+						if buffer[position] != rune('Z') {
+							goto l687
+						}
+						position++
+					}
+				l690:
+					{
+						position692, tokenIndex692 := position, tokenIndex
+						if buffer[position] != rune('r') {
+							goto l693
+						}
+						position++
+						goto l692
+					l693:
+						position, tokenIndex = position692, tokenIndex692
+						if buffer[position] != rune('R') {
+							goto l687
+						}
+						position++
+					}
+				l692:
+					goto l664
+				l687:
+					position, tokenIndex = position664, tokenIndex664
+					{
+						position695, tokenIndex695 := position, tokenIndex
+						if buffer[position] != rune('n') {
+							goto l696
+						}
+						position++
+						goto l695
+					l696:
+						position, tokenIndex = position695, tokenIndex695
+						if buffer[position] != rune('N') {
+							goto l694
+						}
+						position++
+					}
+				l695:
+					{
+						position697, tokenIndex697 := position, tokenIndex
+						if buffer[position] != rune('z') {
+							goto l698
+						}
+						position++
+						goto l697
+					l698:
+						position, tokenIndex = position697, tokenIndex697
+						if buffer[position] != rune('Z') {
+							goto l694
+						}
+						position++
+					}
+				l697:
+					{
+						position699, tokenIndex699 := position, tokenIndex
+						if buffer[position] != rune('c') {
+							goto l700
+						}
+						position++
+						goto l699
+					l700:
+						position, tokenIndex = position699, tokenIndex699
+						if buffer[position] != rune('C') {
+							goto l694
+						}
+						position++
+					}
+				l699:
+					{
+						position701, tokenIndex701 := position, tokenIndex
+						if buffer[position] != rune('v') {
+							goto l702
+						}
+						position++
+						goto l701
+					l702:
+						position, tokenIndex = position701, tokenIndex701
+						if buffer[position] != rune('V') {
+							goto l694
+						}
+						position++
+					}
+				l701:
+					goto l664
+				l694:
+					position, tokenIndex = position664, tokenIndex664
+					if !_rules[ruleSVE2PredicateRegister]() {
+						goto l703
+					}
+					goto l664
+				l703:
+					position, tokenIndex = position664, tokenIndex664
 					if !_rules[ruleARMVectorRegister]() {
-						goto l661
+						goto l704
+					}
+					goto l664
+				l704:
+					position, tokenIndex = position664, tokenIndex664
+					if !_rules[ruleSVE2SpecialValue]() {
+						goto l705
+					}
+					goto l664
+				l705:
+					position, tokenIndex = position664, tokenIndex664
+					if buffer[position] != rune('{') {
+						goto l662
+					}
+					position++
+					{
+						position706, tokenIndex706 := position, tokenIndex
+						if !_rules[ruleWS]() {
+							goto l706
+						}
+						goto l707
+					l706:
+						position, tokenIndex = position706, tokenIndex706
 					}
 				l707:
+					if !_rules[ruleARMVectorRegister]() {
+						goto l662
+					}
+				l708:
 					{
-						position708, tokenIndex708 := position, tokenIndex
+						position709, tokenIndex709 := position, tokenIndex
 						if buffer[position] != rune(',') {
-							goto l708
+							goto l709
 						}
 						position++
 						{
-							position709, tokenIndex709 := position, tokenIndex
+							position710, tokenIndex710 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l709
+								goto l710
 							}
-							goto l710
-						l709:
-							position, tokenIndex = position709, tokenIndex709
+							goto l711
+						l710:
+							position, tokenIndex = position710, tokenIndex710
 						}
-					l710:
+					l711:
 						if !_rules[ruleARMVectorRegister]() {
-							goto l708
+							goto l709
 						}
-						goto l707
-					l708:
-						position, tokenIndex = position708, tokenIndex708
+						goto l708
+					l709:
+						position, tokenIndex = position709, tokenIndex709
 					}
 					{
-						position711, tokenIndex711 := position, tokenIndex
+						position712, tokenIndex712 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l711
+							goto l712
 						}
-						goto l712
-					l711:
-						position, tokenIndex = position711, tokenIndex711
+						goto l713
+					l712:
+						position, tokenIndex = position712, tokenIndex712
 					}
-				l712:
+				l713:
 					if buffer[position] != rune('}') {
-						goto l661
+						goto l662
 					}
 					position++
 					{
-						position713, tokenIndex713 := position, tokenIndex
+						position714, tokenIndex714 := position, tokenIndex
 						if buffer[position] != rune('[') {
-							goto l713
+							goto l714
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l713
+							goto l714
 						}
 						position++
 						{
-							position715, tokenIndex715 := position, tokenIndex
+							position716, tokenIndex716 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l715
+								goto l716
 							}
 							position++
-							goto l716
-						l715:
-							position, tokenIndex = position715, tokenIndex715
+							goto l717
+						l716:
+							position, tokenIndex = position716, tokenIndex716
 						}
-					l716:
+					l717:
 						if buffer[position] != rune(']') {
-							goto l713
+							goto l714
 						}
 						position++
-						goto l714
-					l713:
-						position, tokenIndex = position713, tokenIndex713
+						goto l715
+					l714:
+						position, tokenIndex = position714, tokenIndex714
 					}
-				l714:
+				l715:
 				}
-			l663:
-				add(ruleARMRegister, position662)
+			l664:
+				add(ruleARMRegister, position663)
 			}
 			return true
-		l661:
-			position, tokenIndex = position661, tokenIndex661
+		l662:
+			position, tokenIndex = position662, tokenIndex662
 			return false
 		},
 		/* 47 ARMVectorRegister <- <(('p' / 'v' / 'z') [0-9] [0-9]? !([0-9] / [0-9] / ([a-z] / [A-Z]) / '_') ('.' [0-9]* ('b' / 's' / 'd' / 'h' / 'q') ('[' [0-9] [0-9]? ']')?)?)> */
 		func() bool {
-			position717, tokenIndex717 := position, tokenIndex
+			position718, tokenIndex718 := position, tokenIndex
 			{
-				position718 := position
+				position719 := position
 				{
-					position719, tokenIndex719 := position, tokenIndex
+					position720, tokenIndex720 := position, tokenIndex
 					if buffer[position] != rune('p') {
-						goto l720
-					}
-					position++
-					goto l719
-				l720:
-					position, tokenIndex = position719, tokenIndex719
-					if buffer[position] != rune('v') {
 						goto l721
 					}
 					position++
-					goto l719
+					goto l720
 				l721:
-					position, tokenIndex = position719, tokenIndex719
-					if buffer[position] != rune('z') {
-						goto l717
-					}
-					position++
-				}
-			l719:
-				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l717
-				}
-				position++
-				{
-					position722, tokenIndex722 := position, tokenIndex
-					if c := buffer[position]; c < rune('0') || c > rune('9') {
+					position, tokenIndex = position720, tokenIndex720
+					if buffer[position] != rune('v') {
 						goto l722
 					}
 					position++
-					goto l723
+					goto l720
 				l722:
-					position, tokenIndex = position722, tokenIndex722
+					position, tokenIndex = position720, tokenIndex720
+					if buffer[position] != rune('z') {
+						goto l718
+					}
+					position++
 				}
-			l723:
+			l720:
+				if c := buffer[position]; c < rune('0') || c > rune('9') {
+					goto l718
+				}
+				position++
 				{
-					position724, tokenIndex724 := position, tokenIndex
+					position723, tokenIndex723 := position, tokenIndex
+					if c := buffer[position]; c < rune('0') || c > rune('9') {
+						goto l723
+					}
+					position++
+					goto l724
+				l723:
+					position, tokenIndex = position723, tokenIndex723
+				}
+			l724:
+				{
+					position725, tokenIndex725 := position, tokenIndex
 					{
-						position725, tokenIndex725 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l726
-						}
-						position++
-						goto l725
-					l726:
-						position, tokenIndex = position725, tokenIndex725
+						position726, tokenIndex726 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
 							goto l727
 						}
 						position++
-						goto l725
+						goto l726
 					l727:
-						position, tokenIndex = position725, tokenIndex725
+						position, tokenIndex = position726, tokenIndex726
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l728
+						}
+						position++
+						goto l726
+					l728:
+						position, tokenIndex = position726, tokenIndex726
 						{
-							position729, tokenIndex729 := position, tokenIndex
+							position730, tokenIndex730 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l730
+								goto l731
 							}
 							position++
-							goto l729
-						l730:
-							position, tokenIndex = position729, tokenIndex729
+							goto l730
+						l731:
+							position, tokenIndex = position730, tokenIndex730
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l728
+								goto l729
 							}
 							position++
 						}
+					l730:
+						goto l726
 					l729:
-						goto l725
-					l728:
-						position, tokenIndex = position725, tokenIndex725
+						position, tokenIndex = position726, tokenIndex726
 						if buffer[position] != rune('_') {
-							goto l724
+							goto l725
 						}
 						position++
 					}
+				l726:
+					goto l718
 				l725:
-					goto l717
-				l724:
-					position, tokenIndex = position724, tokenIndex724
+					position, tokenIndex = position725, tokenIndex725
 				}
 				{
-					position731, tokenIndex731 := position, tokenIndex
+					position732, tokenIndex732 := position, tokenIndex
 					if buffer[position] != rune('.') {
-						goto l731
+						goto l732
 					}
 					position++
-				l733:
-					{
-						position734, tokenIndex734 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l734
-						}
-						position++
-						goto l733
-					l734:
-						position, tokenIndex = position734, tokenIndex734
-					}
+				l734:
 					{
 						position735, tokenIndex735 := position, tokenIndex
-						if buffer[position] != rune('b') {
-							goto l736
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l735
 						}
 						position++
-						goto l735
-					l736:
+						goto l734
+					l735:
 						position, tokenIndex = position735, tokenIndex735
-						if buffer[position] != rune('s') {
+					}
+					{
+						position736, tokenIndex736 := position, tokenIndex
+						if buffer[position] != rune('b') {
 							goto l737
 						}
 						position++
-						goto l735
+						goto l736
 					l737:
-						position, tokenIndex = position735, tokenIndex735
-						if buffer[position] != rune('d') {
+						position, tokenIndex = position736, tokenIndex736
+						if buffer[position] != rune('s') {
 							goto l738
 						}
 						position++
-						goto l735
+						goto l736
 					l738:
-						position, tokenIndex = position735, tokenIndex735
-						if buffer[position] != rune('h') {
+						position, tokenIndex = position736, tokenIndex736
+						if buffer[position] != rune('d') {
 							goto l739
 						}
 						position++
-						goto l735
+						goto l736
 					l739:
-						position, tokenIndex = position735, tokenIndex735
+						position, tokenIndex = position736, tokenIndex736
+						if buffer[position] != rune('h') {
+							goto l740
+						}
+						position++
+						goto l736
+					l740:
+						position, tokenIndex = position736, tokenIndex736
 						if buffer[position] != rune('q') {
-							goto l731
+							goto l732
 						}
 						position++
 					}
-				l735:
+				l736:
 					{
-						position740, tokenIndex740 := position, tokenIndex
+						position741, tokenIndex741 := position, tokenIndex
 						if buffer[position] != rune('[') {
-							goto l740
+							goto l741
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l740
+							goto l741
 						}
 						position++
 						{
-							position742, tokenIndex742 := position, tokenIndex
+							position743, tokenIndex743 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l742
+								goto l743
 							}
 							position++
-							goto l743
-						l742:
-							position, tokenIndex = position742, tokenIndex742
+							goto l744
+						l743:
+							position, tokenIndex = position743, tokenIndex743
 						}
-					l743:
+					l744:
 						if buffer[position] != rune(']') {
-							goto l740
+							goto l741
 						}
 						position++
-						goto l741
-					l740:
-						position, tokenIndex = position740, tokenIndex740
+						goto l742
+					l741:
+						position, tokenIndex = position741, tokenIndex741
 					}
-				l741:
-					goto l732
-				l731:
-					position, tokenIndex = position731, tokenIndex731
+				l742:
+					goto l733
+				l732:
+					position, tokenIndex = position732, tokenIndex732
 				}
-			l732:
-				add(ruleARMVectorRegister, position718)
+			l733:
+				add(ruleARMVectorRegister, position719)
 			}
 			return true
-		l717:
-			position, tokenIndex = position717, tokenIndex717
+		l718:
+			position, tokenIndex = position718, tokenIndex718
 			return false
 		},
 		/* 48 SVE2PredicateRegister <- <(('p' / 'P') [0-9] [0-9]? '/' ('m' / 'M' / ('z' / 'Z')))> */
 		func() bool {
-			position744, tokenIndex744 := position, tokenIndex
+			position745, tokenIndex745 := position, tokenIndex
 			{
-				position745 := position
+				position746 := position
 				{
-					position746, tokenIndex746 := position, tokenIndex
+					position747, tokenIndex747 := position, tokenIndex
 					if buffer[position] != rune('p') {
-						goto l747
-					}
-					position++
-					goto l746
-				l747:
-					position, tokenIndex = position746, tokenIndex746
-					if buffer[position] != rune('P') {
-						goto l744
-					}
-					position++
-				}
-			l746:
-				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l744
-				}
-				position++
-				{
-					position748, tokenIndex748 := position, tokenIndex
-					if c := buffer[position]; c < rune('0') || c > rune('9') {
 						goto l748
 					}
 					position++
-					goto l749
+					goto l747
 				l748:
-					position, tokenIndex = position748, tokenIndex748
+					position, tokenIndex = position747, tokenIndex747
+					if buffer[position] != rune('P') {
+						goto l745
+					}
+					position++
 				}
-			l749:
-				if buffer[position] != rune('/') {
-					goto l744
+			l747:
+				if c := buffer[position]; c < rune('0') || c > rune('9') {
+					goto l745
 				}
 				position++
 				{
-					position750, tokenIndex750 := position, tokenIndex
-					if buffer[position] != rune('m') {
-						goto l751
+					position749, tokenIndex749 := position, tokenIndex
+					if c := buffer[position]; c < rune('0') || c > rune('9') {
+						goto l749
 					}
 					position++
 					goto l750
-				l751:
-					position, tokenIndex = position750, tokenIndex750
-					if buffer[position] != rune('M') {
+				l749:
+					position, tokenIndex = position749, tokenIndex749
+				}
+			l750:
+				if buffer[position] != rune('/') {
+					goto l745
+				}
+				position++
+				{
+					position751, tokenIndex751 := position, tokenIndex
+					if buffer[position] != rune('m') {
 						goto l752
 					}
 					position++
-					goto l750
+					goto l751
 				l752:
-					position, tokenIndex = position750, tokenIndex750
+					position, tokenIndex = position751, tokenIndex751
+					if buffer[position] != rune('M') {
+						goto l753
+					}
+					position++
+					goto l751
+				l753:
+					position, tokenIndex = position751, tokenIndex751
 					{
-						position753, tokenIndex753 := position, tokenIndex
+						position754, tokenIndex754 := position, tokenIndex
 						if buffer[position] != rune('z') {
-							goto l754
+							goto l755
 						}
 						position++
-						goto l753
-					l754:
-						position, tokenIndex = position753, tokenIndex753
+						goto l754
+					l755:
+						position, tokenIndex = position754, tokenIndex754
 						if buffer[position] != rune('Z') {
-							goto l744
+							goto l745
 						}
 						position++
 					}
-				l753:
+				l754:
 				}
-			l750:
-				add(ruleSVE2PredicateRegister, position745)
+			l751:
+				add(ruleSVE2PredicateRegister, position746)
 			}
 			return true
-		l744:
-			position, tokenIndex = position744, tokenIndex744
+		l745:
+			position, tokenIndex = position745, tokenIndex745
 			return false
 		},
 		/* 49 SVE2SpecialValue <- <(((('p' / 'P') ('o' / 'O') ('w' / 'W') '2') / (('v' / 'V') ('l' / 'L') ('1' / '2' / '3' / '4' / '5' / '6' / '7' / '8') ![0-9]) / (('v' / 'V') ('l' / 'L') '1' '6') / (('v' / 'V') ('l' / 'L') '3' '2') / (('v' / 'V') ('l' / 'L') '6' '4') / (('v' / 'V') ('l' / 'L') '1' '2' '8') / (('v' / 'V') ('l' / 'L') '2' '5' '6') / (('m' / 'M') ('u' / 'U') ('l' / 'L') '3') / (('m' / 'M') ('u' / 'U') ('l' / 'L') '4') / (('a' / 'A') ('l' / 'L') ('l' / 'L'))) !([0-9] / [0-9] / ([a-z] / [A-Z]) / '_'))> */
 		func() bool {
-			position755, tokenIndex755 := position, tokenIndex
+			position756, tokenIndex756 := position, tokenIndex
 			{
-				position756 := position
+				position757 := position
 				{
-					position757, tokenIndex757 := position, tokenIndex
+					position758, tokenIndex758 := position, tokenIndex
 					{
-						position759, tokenIndex759 := position, tokenIndex
+						position760, tokenIndex760 := position, tokenIndex
 						if buffer[position] != rune('p') {
-							goto l760
+							goto l761
 						}
 						position++
-						goto l759
-					l760:
-						position, tokenIndex = position759, tokenIndex759
+						goto l760
+					l761:
+						position, tokenIndex = position760, tokenIndex760
 						if buffer[position] != rune('P') {
-							goto l758
+							goto l759
 						}
 						position++
 					}
-				l759:
+				l760:
 					{
-						position761, tokenIndex761 := position, tokenIndex
+						position762, tokenIndex762 := position, tokenIndex
 						if buffer[position] != rune('o') {
-							goto l762
+							goto l763
 						}
 						position++
-						goto l761
-					l762:
-						position, tokenIndex = position761, tokenIndex761
+						goto l762
+					l763:
+						position, tokenIndex = position762, tokenIndex762
 						if buffer[position] != rune('O') {
-							goto l758
+							goto l759
 						}
 						position++
 					}
-				l761:
+				l762:
 					{
-						position763, tokenIndex763 := position, tokenIndex
+						position764, tokenIndex764 := position, tokenIndex
 						if buffer[position] != rune('w') {
-							goto l764
+							goto l765
 						}
 						position++
-						goto l763
-					l764:
-						position, tokenIndex = position763, tokenIndex763
+						goto l764
+					l765:
+						position, tokenIndex = position764, tokenIndex764
 						if buffer[position] != rune('W') {
-							goto l758
+							goto l759
 						}
 						position++
 					}
-				l763:
+				l764:
 					if buffer[position] != rune('2') {
-						goto l758
+						goto l759
 					}
 					position++
-					goto l757
-				l758:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l759:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position766, tokenIndex766 := position, tokenIndex
+						position767, tokenIndex767 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l767
+							goto l768
 						}
 						position++
-						goto l766
-					l767:
-						position, tokenIndex = position766, tokenIndex766
+						goto l767
+					l768:
+						position, tokenIndex = position767, tokenIndex767
 						if buffer[position] != rune('V') {
-							goto l765
+							goto l766
 						}
 						position++
 					}
-				l766:
+				l767:
 					{
-						position768, tokenIndex768 := position, tokenIndex
+						position769, tokenIndex769 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l769
+							goto l770
 						}
 						position++
-						goto l768
-					l769:
-						position, tokenIndex = position768, tokenIndex768
+						goto l769
+					l770:
+						position, tokenIndex = position769, tokenIndex769
 						if buffer[position] != rune('L') {
-							goto l765
+							goto l766
 						}
 						position++
 					}
-				l768:
+				l769:
 					{
-						position770, tokenIndex770 := position, tokenIndex
+						position771, tokenIndex771 := position, tokenIndex
 						if buffer[position] != rune('1') {
-							goto l771
-						}
-						position++
-						goto l770
-					l771:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('2') {
 							goto l772
 						}
 						position++
-						goto l770
+						goto l771
 					l772:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('3') {
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('2') {
 							goto l773
 						}
 						position++
-						goto l770
+						goto l771
 					l773:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('4') {
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('3') {
 							goto l774
 						}
 						position++
-						goto l770
+						goto l771
 					l774:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('5') {
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('4') {
 							goto l775
 						}
 						position++
-						goto l770
+						goto l771
 					l775:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('6') {
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('5') {
 							goto l776
 						}
 						position++
-						goto l770
+						goto l771
 					l776:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('7') {
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('6') {
 							goto l777
 						}
 						position++
-						goto l770
+						goto l771
 					l777:
-						position, tokenIndex = position770, tokenIndex770
-						if buffer[position] != rune('8') {
-							goto l765
-						}
-						position++
-					}
-				l770:
-					{
-						position778, tokenIndex778 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('7') {
 							goto l778
 						}
 						position++
-						goto l765
+						goto l771
 					l778:
-						position, tokenIndex = position778, tokenIndex778
+						position, tokenIndex = position771, tokenIndex771
+						if buffer[position] != rune('8') {
+							goto l766
+						}
+						position++
 					}
-					goto l757
-				l765:
-					position, tokenIndex = position757, tokenIndex757
+				l771:
 					{
-						position780, tokenIndex780 := position, tokenIndex
+						position779, tokenIndex779 := position, tokenIndex
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l779
+						}
+						position++
+						goto l766
+					l779:
+						position, tokenIndex = position779, tokenIndex779
+					}
+					goto l758
+				l766:
+					position, tokenIndex = position758, tokenIndex758
+					{
+						position781, tokenIndex781 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l781
+							goto l782
 						}
 						position++
-						goto l780
-					l781:
-						position, tokenIndex = position780, tokenIndex780
+						goto l781
+					l782:
+						position, tokenIndex = position781, tokenIndex781
 						if buffer[position] != rune('V') {
-							goto l779
+							goto l780
 						}
 						position++
 					}
-				l780:
+				l781:
 					{
-						position782, tokenIndex782 := position, tokenIndex
+						position783, tokenIndex783 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l783
+							goto l784
 						}
 						position++
-						goto l782
-					l783:
-						position, tokenIndex = position782, tokenIndex782
+						goto l783
+					l784:
+						position, tokenIndex = position783, tokenIndex783
 						if buffer[position] != rune('L') {
-							goto l779
+							goto l780
 						}
 						position++
 					}
-				l782:
+				l783:
 					if buffer[position] != rune('1') {
-						goto l779
+						goto l780
 					}
 					position++
 					if buffer[position] != rune('6') {
-						goto l779
+						goto l780
 					}
 					position++
-					goto l757
-				l779:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l780:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position785, tokenIndex785 := position, tokenIndex
+						position786, tokenIndex786 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l786
+							goto l787
 						}
 						position++
-						goto l785
-					l786:
-						position, tokenIndex = position785, tokenIndex785
+						goto l786
+					l787:
+						position, tokenIndex = position786, tokenIndex786
 						if buffer[position] != rune('V') {
-							goto l784
+							goto l785
 						}
 						position++
 					}
-				l785:
+				l786:
 					{
-						position787, tokenIndex787 := position, tokenIndex
+						position788, tokenIndex788 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l788
+							goto l789
 						}
 						position++
-						goto l787
-					l788:
-						position, tokenIndex = position787, tokenIndex787
+						goto l788
+					l789:
+						position, tokenIndex = position788, tokenIndex788
 						if buffer[position] != rune('L') {
-							goto l784
+							goto l785
 						}
 						position++
 					}
-				l787:
+				l788:
 					if buffer[position] != rune('3') {
-						goto l784
+						goto l785
 					}
 					position++
 					if buffer[position] != rune('2') {
-						goto l784
+						goto l785
 					}
 					position++
-					goto l757
-				l784:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l785:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position790, tokenIndex790 := position, tokenIndex
+						position791, tokenIndex791 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l791
+							goto l792
 						}
 						position++
-						goto l790
-					l791:
-						position, tokenIndex = position790, tokenIndex790
+						goto l791
+					l792:
+						position, tokenIndex = position791, tokenIndex791
 						if buffer[position] != rune('V') {
-							goto l789
+							goto l790
 						}
 						position++
 					}
-				l790:
+				l791:
 					{
-						position792, tokenIndex792 := position, tokenIndex
+						position793, tokenIndex793 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l793
+							goto l794
 						}
 						position++
-						goto l792
-					l793:
-						position, tokenIndex = position792, tokenIndex792
+						goto l793
+					l794:
+						position, tokenIndex = position793, tokenIndex793
 						if buffer[position] != rune('L') {
-							goto l789
+							goto l790
 						}
 						position++
 					}
-				l792:
+				l793:
 					if buffer[position] != rune('6') {
-						goto l789
+						goto l790
 					}
 					position++
 					if buffer[position] != rune('4') {
-						goto l789
+						goto l790
 					}
 					position++
-					goto l757
-				l789:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l790:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position795, tokenIndex795 := position, tokenIndex
+						position796, tokenIndex796 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l796
+							goto l797
 						}
 						position++
-						goto l795
-					l796:
-						position, tokenIndex = position795, tokenIndex795
+						goto l796
+					l797:
+						position, tokenIndex = position796, tokenIndex796
 						if buffer[position] != rune('V') {
-							goto l794
+							goto l795
 						}
 						position++
 					}
-				l795:
+				l796:
 					{
-						position797, tokenIndex797 := position, tokenIndex
+						position798, tokenIndex798 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l798
+							goto l799
 						}
 						position++
-						goto l797
-					l798:
-						position, tokenIndex = position797, tokenIndex797
+						goto l798
+					l799:
+						position, tokenIndex = position798, tokenIndex798
 						if buffer[position] != rune('L') {
-							goto l794
+							goto l795
 						}
 						position++
 					}
-				l797:
+				l798:
 					if buffer[position] != rune('1') {
-						goto l794
+						goto l795
 					}
 					position++
 					if buffer[position] != rune('2') {
-						goto l794
+						goto l795
 					}
 					position++
 					if buffer[position] != rune('8') {
-						goto l794
+						goto l795
 					}
 					position++
-					goto l757
-				l794:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l795:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position800, tokenIndex800 := position, tokenIndex
+						position801, tokenIndex801 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l801
+							goto l802
 						}
 						position++
-						goto l800
-					l801:
-						position, tokenIndex = position800, tokenIndex800
+						goto l801
+					l802:
+						position, tokenIndex = position801, tokenIndex801
 						if buffer[position] != rune('V') {
-							goto l799
+							goto l800
 						}
 						position++
 					}
-				l800:
+				l801:
 					{
-						position802, tokenIndex802 := position, tokenIndex
+						position803, tokenIndex803 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l803
+							goto l804
 						}
 						position++
-						goto l802
-					l803:
-						position, tokenIndex = position802, tokenIndex802
+						goto l803
+					l804:
+						position, tokenIndex = position803, tokenIndex803
 						if buffer[position] != rune('L') {
-							goto l799
+							goto l800
 						}
 						position++
 					}
-				l802:
+				l803:
 					if buffer[position] != rune('2') {
-						goto l799
+						goto l800
 					}
 					position++
 					if buffer[position] != rune('5') {
-						goto l799
+						goto l800
 					}
 					position++
 					if buffer[position] != rune('6') {
-						goto l799
+						goto l800
 					}
 					position++
-					goto l757
-				l799:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l800:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position805, tokenIndex805 := position, tokenIndex
+						position806, tokenIndex806 := position, tokenIndex
 						if buffer[position] != rune('m') {
-							goto l806
+							goto l807
 						}
 						position++
-						goto l805
-					l806:
-						position, tokenIndex = position805, tokenIndex805
+						goto l806
+					l807:
+						position, tokenIndex = position806, tokenIndex806
 						if buffer[position] != rune('M') {
-							goto l804
+							goto l805
 						}
 						position++
 					}
-				l805:
+				l806:
 					{
-						position807, tokenIndex807 := position, tokenIndex
+						position808, tokenIndex808 := position, tokenIndex
 						if buffer[position] != rune('u') {
-							goto l808
+							goto l809
 						}
 						position++
-						goto l807
-					l808:
-						position, tokenIndex = position807, tokenIndex807
+						goto l808
+					l809:
+						position, tokenIndex = position808, tokenIndex808
 						if buffer[position] != rune('U') {
-							goto l804
+							goto l805
 						}
 						position++
 					}
-				l807:
+				l808:
 					{
-						position809, tokenIndex809 := position, tokenIndex
+						position810, tokenIndex810 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l810
+							goto l811
 						}
 						position++
-						goto l809
-					l810:
-						position, tokenIndex = position809, tokenIndex809
+						goto l810
+					l811:
+						position, tokenIndex = position810, tokenIndex810
 						if buffer[position] != rune('L') {
-							goto l804
+							goto l805
 						}
 						position++
 					}
-				l809:
+				l810:
 					if buffer[position] != rune('3') {
-						goto l804
+						goto l805
 					}
 					position++
-					goto l757
-				l804:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l805:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position812, tokenIndex812 := position, tokenIndex
+						position813, tokenIndex813 := position, tokenIndex
 						if buffer[position] != rune('m') {
-							goto l813
+							goto l814
 						}
 						position++
-						goto l812
-					l813:
-						position, tokenIndex = position812, tokenIndex812
+						goto l813
+					l814:
+						position, tokenIndex = position813, tokenIndex813
 						if buffer[position] != rune('M') {
-							goto l811
+							goto l812
 						}
 						position++
 					}
-				l812:
+				l813:
 					{
-						position814, tokenIndex814 := position, tokenIndex
+						position815, tokenIndex815 := position, tokenIndex
 						if buffer[position] != rune('u') {
-							goto l815
+							goto l816
 						}
 						position++
-						goto l814
-					l815:
-						position, tokenIndex = position814, tokenIndex814
+						goto l815
+					l816:
+						position, tokenIndex = position815, tokenIndex815
 						if buffer[position] != rune('U') {
-							goto l811
+							goto l812
 						}
 						position++
 					}
-				l814:
+				l815:
 					{
-						position816, tokenIndex816 := position, tokenIndex
+						position817, tokenIndex817 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l817
+							goto l818
 						}
 						position++
-						goto l816
-					l817:
-						position, tokenIndex = position816, tokenIndex816
+						goto l817
+					l818:
+						position, tokenIndex = position817, tokenIndex817
 						if buffer[position] != rune('L') {
-							goto l811
+							goto l812
 						}
 						position++
 					}
-				l816:
+				l817:
 					if buffer[position] != rune('4') {
-						goto l811
+						goto l812
 					}
 					position++
-					goto l757
-				l811:
-					position, tokenIndex = position757, tokenIndex757
+					goto l758
+				l812:
+					position, tokenIndex = position758, tokenIndex758
 					{
-						position818, tokenIndex818 := position, tokenIndex
+						position819, tokenIndex819 := position, tokenIndex
 						if buffer[position] != rune('a') {
-							goto l819
+							goto l820
 						}
 						position++
-						goto l818
-					l819:
-						position, tokenIndex = position818, tokenIndex818
+						goto l819
+					l820:
+						position, tokenIndex = position819, tokenIndex819
 						if buffer[position] != rune('A') {
-							goto l755
+							goto l756
 						}
 						position++
 					}
-				l818:
+				l819:
 					{
-						position820, tokenIndex820 := position, tokenIndex
+						position821, tokenIndex821 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l821
+							goto l822
 						}
 						position++
-						goto l820
-					l821:
-						position, tokenIndex = position820, tokenIndex820
+						goto l821
+					l822:
+						position, tokenIndex = position821, tokenIndex821
 						if buffer[position] != rune('L') {
-							goto l755
+							goto l756
 						}
 						position++
 					}
-				l820:
+				l821:
 					{
-						position822, tokenIndex822 := position, tokenIndex
+						position823, tokenIndex823 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l823
+							goto l824
 						}
 						position++
-						goto l822
-					l823:
-						position, tokenIndex = position822, tokenIndex822
+						goto l823
+					l824:
+						position, tokenIndex = position823, tokenIndex823
 						if buffer[position] != rune('L') {
-							goto l755
+							goto l756
 						}
 						position++
 					}
-				l822:
+				l823:
 				}
-			l757:
+			l758:
 				{
-					position824, tokenIndex824 := position, tokenIndex
+					position825, tokenIndex825 := position, tokenIndex
 					{
-						position825, tokenIndex825 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l826
-						}
-						position++
-						goto l825
-					l826:
-						position, tokenIndex = position825, tokenIndex825
+						position826, tokenIndex826 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
 							goto l827
 						}
 						position++
-						goto l825
+						goto l826
 					l827:
-						position, tokenIndex = position825, tokenIndex825
+						position, tokenIndex = position826, tokenIndex826
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l828
+						}
+						position++
+						goto l826
+					l828:
+						position, tokenIndex = position826, tokenIndex826
 						{
-							position829, tokenIndex829 := position, tokenIndex
+							position830, tokenIndex830 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l830
+								goto l831
 							}
 							position++
-							goto l829
-						l830:
-							position, tokenIndex = position829, tokenIndex829
+							goto l830
+						l831:
+							position, tokenIndex = position830, tokenIndex830
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l828
+								goto l829
 							}
 							position++
 						}
+					l830:
+						goto l826
 					l829:
-						goto l825
-					l828:
-						position, tokenIndex = position825, tokenIndex825
+						position, tokenIndex = position826, tokenIndex826
 						if buffer[position] != rune('_') {
-							goto l824
+							goto l825
 						}
 						position++
 					}
+				l826:
+					goto l756
 				l825:
-					goto l755
-				l824:
-					position, tokenIndex = position824, tokenIndex824
+					position, tokenIndex = position825, tokenIndex825
 				}
-				add(ruleSVE2SpecialValue, position756)
+				add(ruleSVE2SpecialValue, position757)
 			}
 			return true
-		l755:
-			position, tokenIndex = position755, tokenIndex755
+		l756:
+			position, tokenIndex = position756, tokenIndex756
 			return false
 		},
 		/* 50 MemoryRef <- <((SymbolRef BaseIndexScale) / SymbolRef / Low12BitsSymbolRef / (Offset* BaseIndexScale) / (SegmentRegister Offset BaseIndexScale) / (SegmentRegister BaseIndexScale) / (SegmentRegister Offset) / ARMBaseIndexScale / BaseIndexScale)> */
 		func() bool {
-			position831, tokenIndex831 := position, tokenIndex
+			position832, tokenIndex832 := position, tokenIndex
 			{
-				position832 := position
+				position833 := position
 				{
-					position833, tokenIndex833 := position, tokenIndex
-					if !_rules[ruleSymbolRef]() {
-						goto l834
-					}
-					if !_rules[ruleBaseIndexScale]() {
-						goto l834
-					}
-					goto l833
-				l834:
-					position, tokenIndex = position833, tokenIndex833
+					position834, tokenIndex834 := position, tokenIndex
 					if !_rules[ruleSymbolRef]() {
 						goto l835
 					}
-					goto l833
+					if !_rules[ruleBaseIndexScale]() {
+						goto l835
+					}
+					goto l834
 				l835:
-					position, tokenIndex = position833, tokenIndex833
-					if !_rules[ruleLow12BitsSymbolRef]() {
+					position, tokenIndex = position834, tokenIndex834
+					if !_rules[ruleSymbolRef]() {
 						goto l836
 					}
-					goto l833
+					goto l834
 				l836:
-					position, tokenIndex = position833, tokenIndex833
-				l838:
-					{
-						position839, tokenIndex839 := position, tokenIndex
-						if !_rules[ruleOffset]() {
-							goto l839
-						}
-						goto l838
-					l839:
-						position, tokenIndex = position839, tokenIndex839
-					}
-					if !_rules[ruleBaseIndexScale]() {
+					position, tokenIndex = position834, tokenIndex834
+					if !_rules[ruleLow12BitsSymbolRef]() {
 						goto l837
 					}
-					goto l833
+					goto l834
 				l837:
-					position, tokenIndex = position833, tokenIndex833
+					position, tokenIndex = position834, tokenIndex834
+				l839:
+					{
+						position840, tokenIndex840 := position, tokenIndex
+						if !_rules[ruleOffset]() {
+							goto l840
+						}
+						goto l839
+					l840:
+						position, tokenIndex = position840, tokenIndex840
+					}
+					if !_rules[ruleBaseIndexScale]() {
+						goto l838
+					}
+					goto l834
+				l838:
+					position, tokenIndex = position834, tokenIndex834
 					if !_rules[ruleSegmentRegister]() {
-						goto l840
+						goto l841
 					}
 					if !_rules[ruleOffset]() {
-						goto l840
-					}
-					if !_rules[ruleBaseIndexScale]() {
-						goto l840
-					}
-					goto l833
-				l840:
-					position, tokenIndex = position833, tokenIndex833
-					if !_rules[ruleSegmentRegister]() {
 						goto l841
 					}
 					if !_rules[ruleBaseIndexScale]() {
 						goto l841
 					}
-					goto l833
+					goto l834
 				l841:
-					position, tokenIndex = position833, tokenIndex833
+					position, tokenIndex = position834, tokenIndex834
 					if !_rules[ruleSegmentRegister]() {
 						goto l842
 					}
-					if !_rules[ruleOffset]() {
+					if !_rules[ruleBaseIndexScale]() {
 						goto l842
 					}
-					goto l833
+					goto l834
 				l842:
-					position, tokenIndex = position833, tokenIndex833
-					if !_rules[ruleARMBaseIndexScale]() {
+					position, tokenIndex = position834, tokenIndex834
+					if !_rules[ruleSegmentRegister]() {
 						goto l843
 					}
-					goto l833
+					if !_rules[ruleOffset]() {
+						goto l843
+					}
+					goto l834
 				l843:
-					position, tokenIndex = position833, tokenIndex833
+					position, tokenIndex = position834, tokenIndex834
+					if !_rules[ruleARMBaseIndexScale]() {
+						goto l844
+					}
+					goto l834
+				l844:
+					position, tokenIndex = position834, tokenIndex834
 					if !_rules[ruleBaseIndexScale]() {
-						goto l831
+						goto l832
 					}
 				}
-			l833:
-				add(ruleMemoryRef, position832)
+			l834:
+				add(ruleMemoryRef, position833)
 			}
 			return true
-		l831:
-			position, tokenIndex = position831, tokenIndex831
+		l832:
+			position, tokenIndex = position832, tokenIndex832
 			return false
 		},
 		/* 51 SymbolRef <- <((Offset* '+')? (LocalSymbol / SymbolName) Offset* ('@' Section Offset*)?)> */
 		func() bool {
-			position844, tokenIndex844 := position, tokenIndex
+			position845, tokenIndex845 := position, tokenIndex
 			{
-				position845 := position
+				position846 := position
 				{
-					position846, tokenIndex846 := position, tokenIndex
-				l848:
+					position847, tokenIndex847 := position, tokenIndex
+				l849:
 					{
-						position849, tokenIndex849 := position, tokenIndex
+						position850, tokenIndex850 := position, tokenIndex
 						if !_rules[ruleOffset]() {
-							goto l849
+							goto l850
 						}
-						goto l848
-					l849:
-						position, tokenIndex = position849, tokenIndex849
+						goto l849
+					l850:
+						position, tokenIndex = position850, tokenIndex850
 					}
 					if buffer[position] != rune('+') {
-						goto l846
+						goto l847
 					}
 					position++
-					goto l847
-				l846:
-					position, tokenIndex = position846, tokenIndex846
+					goto l848
+				l847:
+					position, tokenIndex = position847, tokenIndex847
 				}
-			l847:
+			l848:
 				{
-					position850, tokenIndex850 := position, tokenIndex
+					position851, tokenIndex851 := position, tokenIndex
 					if !_rules[ruleLocalSymbol]() {
-						goto l851
+						goto l852
 					}
-					goto l850
-				l851:
-					position, tokenIndex = position850, tokenIndex850
+					goto l851
+				l852:
+					position, tokenIndex = position851, tokenIndex851
 					if !_rules[ruleSymbolName]() {
-						goto l844
+						goto l845
 					}
 				}
-			l850:
-			l852:
-				{
-					position853, tokenIndex853 := position, tokenIndex
-					if !_rules[ruleOffset]() {
-						goto l853
-					}
-					goto l852
-				l853:
-					position, tokenIndex = position853, tokenIndex853
-				}
+			l851:
+			l853:
 				{
 					position854, tokenIndex854 := position, tokenIndex
-					if buffer[position] != rune('@') {
+					if !_rules[ruleOffset]() {
 						goto l854
 					}
-					position++
-					if !_rules[ruleSection]() {
-						goto l854
-					}
-				l856:
-					{
-						position857, tokenIndex857 := position, tokenIndex
-						if !_rules[ruleOffset]() {
-							goto l857
-						}
-						goto l856
-					l857:
-						position, tokenIndex = position857, tokenIndex857
-					}
-					goto l855
+					goto l853
 				l854:
 					position, tokenIndex = position854, tokenIndex854
 				}
-			l855:
-				add(ruleSymbolRef, position845)
+				{
+					position855, tokenIndex855 := position, tokenIndex
+					if buffer[position] != rune('@') {
+						goto l855
+					}
+					position++
+					if !_rules[ruleSection]() {
+						goto l855
+					}
+				l857:
+					{
+						position858, tokenIndex858 := position, tokenIndex
+						if !_rules[ruleOffset]() {
+							goto l858
+						}
+						goto l857
+					l858:
+						position, tokenIndex = position858, tokenIndex858
+					}
+					goto l856
+				l855:
+					position, tokenIndex = position855, tokenIndex855
+				}
+			l856:
+				add(ruleSymbolRef, position846)
 			}
 			return true
-		l844:
-			position, tokenIndex = position844, tokenIndex844
+		l845:
+			position, tokenIndex = position845, tokenIndex845
 			return false
 		},
 		/* 52 Low12BitsSymbolRef <- <(':' ('l' / 'L') ('o' / 'O') '1' '2' ':' (LocalSymbol / SymbolName) Offset?)> */
 		func() bool {
-			position858, tokenIndex858 := position, tokenIndex
+			position859, tokenIndex859 := position, tokenIndex
 			{
-				position859 := position
+				position860 := position
 				if buffer[position] != rune(':') {
-					goto l858
+					goto l859
 				}
 				position++
 				{
-					position860, tokenIndex860 := position, tokenIndex
+					position861, tokenIndex861 := position, tokenIndex
 					if buffer[position] != rune('l') {
-						goto l861
+						goto l862
 					}
 					position++
-					goto l860
-				l861:
-					position, tokenIndex = position860, tokenIndex860
+					goto l861
+				l862:
+					position, tokenIndex = position861, tokenIndex861
 					if buffer[position] != rune('L') {
-						goto l858
+						goto l859
 					}
 					position++
 				}
-			l860:
+			l861:
 				{
-					position862, tokenIndex862 := position, tokenIndex
+					position863, tokenIndex863 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l863
+						goto l864
 					}
 					position++
-					goto l862
-				l863:
-					position, tokenIndex = position862, tokenIndex862
+					goto l863
+				l864:
+					position, tokenIndex = position863, tokenIndex863
 					if buffer[position] != rune('O') {
-						goto l858
+						goto l859
 					}
 					position++
 				}
-			l862:
+			l863:
 				if buffer[position] != rune('1') {
-					goto l858
+					goto l859
 				}
 				position++
 				if buffer[position] != rune('2') {
-					goto l858
+					goto l859
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l858
+					goto l859
 				}
 				position++
 				{
-					position864, tokenIndex864 := position, tokenIndex
+					position865, tokenIndex865 := position, tokenIndex
 					if !_rules[ruleLocalSymbol]() {
-						goto l865
-					}
-					goto l864
-				l865:
-					position, tokenIndex = position864, tokenIndex864
-					if !_rules[ruleSymbolName]() {
-						goto l858
-					}
-				}
-			l864:
-				{
-					position866, tokenIndex866 := position, tokenIndex
-					if !_rules[ruleOffset]() {
 						goto l866
 					}
-					goto l867
+					goto l865
 				l866:
-					position, tokenIndex = position866, tokenIndex866
+					position, tokenIndex = position865, tokenIndex865
+					if !_rules[ruleSymbolName]() {
+						goto l859
+					}
 				}
-			l867:
-				add(ruleLow12BitsSymbolRef, position859)
+			l865:
+				{
+					position867, tokenIndex867 := position, tokenIndex
+					if !_rules[ruleOffset]() {
+						goto l867
+					}
+					goto l868
+				l867:
+					position, tokenIndex = position867, tokenIndex867
+				}
+			l868:
+				add(ruleLow12BitsSymbolRef, position860)
 			}
 			return true
-		l858:
-			position, tokenIndex = position858, tokenIndex858
+		l859:
+			position, tokenIndex = position859, tokenIndex859
 			return false
 		},
 		/* 53 ARMBaseIndexScale <- <('[' ARMRegister (',' WS? (('#' Offset (('*' [0-9]+) / ('*' '(' [0-9]+ Operator [0-9]+ ')') / ('+' [0-9]+)*)?) / ARMGOTLow12 / Low12BitsSymbolRef / ARMRegister) (',' WS? ARMConstantTweak)?)? ']' ARMPostincrement?)> */
 		func() bool {
-			position868, tokenIndex868 := position, tokenIndex
+			position869, tokenIndex869 := position, tokenIndex
 			{
-				position869 := position
+				position870 := position
 				if buffer[position] != rune('[') {
-					goto l868
+					goto l869
 				}
 				position++
 				if !_rules[ruleARMRegister]() {
-					goto l868
+					goto l869
 				}
 				{
-					position870, tokenIndex870 := position, tokenIndex
+					position871, tokenIndex871 := position, tokenIndex
 					if buffer[position] != rune(',') {
-						goto l870
+						goto l871
 					}
 					position++
 					{
-						position872, tokenIndex872 := position, tokenIndex
+						position873, tokenIndex873 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l872
-						}
-						goto l873
-					l872:
-						position, tokenIndex = position872, tokenIndex872
-					}
-				l873:
-					{
-						position874, tokenIndex874 := position, tokenIndex
-						if buffer[position] != rune('#') {
-							goto l875
-						}
-						position++
-						if !_rules[ruleOffset]() {
-							goto l875
-						}
-						{
-							position876, tokenIndex876 := position, tokenIndex
-							{
-								position878, tokenIndex878 := position, tokenIndex
-								if buffer[position] != rune('*') {
-									goto l879
-								}
-								position++
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l879
-								}
-								position++
-							l880:
-								{
-									position881, tokenIndex881 := position, tokenIndex
-									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l881
-									}
-									position++
-									goto l880
-								l881:
-									position, tokenIndex = position881, tokenIndex881
-								}
-								goto l878
-							l879:
-								position, tokenIndex = position878, tokenIndex878
-								if buffer[position] != rune('*') {
-									goto l882
-								}
-								position++
-								if buffer[position] != rune('(') {
-									goto l882
-								}
-								position++
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l882
-								}
-								position++
-							l883:
-								{
-									position884, tokenIndex884 := position, tokenIndex
-									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l884
-									}
-									position++
-									goto l883
-								l884:
-									position, tokenIndex = position884, tokenIndex884
-								}
-								if !_rules[ruleOperator]() {
-									goto l882
-								}
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l882
-								}
-								position++
-							l885:
-								{
-									position886, tokenIndex886 := position, tokenIndex
-									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l886
-									}
-									position++
-									goto l885
-								l886:
-									position, tokenIndex = position886, tokenIndex886
-								}
-								if buffer[position] != rune(')') {
-									goto l882
-								}
-								position++
-								goto l878
-							l882:
-								position, tokenIndex = position878, tokenIndex878
-							l887:
-								{
-									position888, tokenIndex888 := position, tokenIndex
-									if buffer[position] != rune('+') {
-										goto l888
-									}
-									position++
-									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l888
-									}
-									position++
-								l889:
-									{
-										position890, tokenIndex890 := position, tokenIndex
-										if c := buffer[position]; c < rune('0') || c > rune('9') {
-											goto l890
-										}
-										position++
-										goto l889
-									l890:
-										position, tokenIndex = position890, tokenIndex890
-									}
-									goto l887
-								l888:
-									position, tokenIndex = position888, tokenIndex888
-								}
-							}
-						l878:
-							goto l877
-
-							position, tokenIndex = position876, tokenIndex876
-						}
-					l877:
-						goto l874
-					l875:
-						position, tokenIndex = position874, tokenIndex874
-						if !_rules[ruleARMGOTLow12]() {
-							goto l891
+							goto l873
 						}
 						goto l874
-					l891:
-						position, tokenIndex = position874, tokenIndex874
-						if !_rules[ruleLow12BitsSymbolRef]() {
-							goto l892
-						}
-						goto l874
-					l892:
-						position, tokenIndex = position874, tokenIndex874
-						if !_rules[ruleARMRegister]() {
-							goto l870
-						}
+					l873:
+						position, tokenIndex = position873, tokenIndex873
 					}
 				l874:
 					{
-						position893, tokenIndex893 := position, tokenIndex
-						if buffer[position] != rune(',') {
+						position875, tokenIndex875 := position, tokenIndex
+						if buffer[position] != rune('#') {
+							goto l876
+						}
+						position++
+						if !_rules[ruleOffset]() {
+							goto l876
+						}
+						{
+							position877, tokenIndex877 := position, tokenIndex
+							{
+								position879, tokenIndex879 := position, tokenIndex
+								if buffer[position] != rune('*') {
+									goto l880
+								}
+								position++
+								if c := buffer[position]; c < rune('0') || c > rune('9') {
+									goto l880
+								}
+								position++
+							l881:
+								{
+									position882, tokenIndex882 := position, tokenIndex
+									if c := buffer[position]; c < rune('0') || c > rune('9') {
+										goto l882
+									}
+									position++
+									goto l881
+								l882:
+									position, tokenIndex = position882, tokenIndex882
+								}
+								goto l879
+							l880:
+								position, tokenIndex = position879, tokenIndex879
+								if buffer[position] != rune('*') {
+									goto l883
+								}
+								position++
+								if buffer[position] != rune('(') {
+									goto l883
+								}
+								position++
+								if c := buffer[position]; c < rune('0') || c > rune('9') {
+									goto l883
+								}
+								position++
+							l884:
+								{
+									position885, tokenIndex885 := position, tokenIndex
+									if c := buffer[position]; c < rune('0') || c > rune('9') {
+										goto l885
+									}
+									position++
+									goto l884
+								l885:
+									position, tokenIndex = position885, tokenIndex885
+								}
+								if !_rules[ruleOperator]() {
+									goto l883
+								}
+								if c := buffer[position]; c < rune('0') || c > rune('9') {
+									goto l883
+								}
+								position++
+							l886:
+								{
+									position887, tokenIndex887 := position, tokenIndex
+									if c := buffer[position]; c < rune('0') || c > rune('9') {
+										goto l887
+									}
+									position++
+									goto l886
+								l887:
+									position, tokenIndex = position887, tokenIndex887
+								}
+								if buffer[position] != rune(')') {
+									goto l883
+								}
+								position++
+								goto l879
+							l883:
+								position, tokenIndex = position879, tokenIndex879
+							l888:
+								{
+									position889, tokenIndex889 := position, tokenIndex
+									if buffer[position] != rune('+') {
+										goto l889
+									}
+									position++
+									if c := buffer[position]; c < rune('0') || c > rune('9') {
+										goto l889
+									}
+									position++
+								l890:
+									{
+										position891, tokenIndex891 := position, tokenIndex
+										if c := buffer[position]; c < rune('0') || c > rune('9') {
+											goto l891
+										}
+										position++
+										goto l890
+									l891:
+										position, tokenIndex = position891, tokenIndex891
+									}
+									goto l888
+								l889:
+									position, tokenIndex = position889, tokenIndex889
+								}
+							}
+						l879:
+							goto l878
+
+							position, tokenIndex = position877, tokenIndex877
+						}
+					l878:
+						goto l875
+					l876:
+						position, tokenIndex = position875, tokenIndex875
+						if !_rules[ruleARMGOTLow12]() {
+							goto l892
+						}
+						goto l875
+					l892:
+						position, tokenIndex = position875, tokenIndex875
+						if !_rules[ruleLow12BitsSymbolRef]() {
 							goto l893
 						}
+						goto l875
+					l893:
+						position, tokenIndex = position875, tokenIndex875
+						if !_rules[ruleARMRegister]() {
+							goto l871
+						}
+					}
+				l875:
+					{
+						position894, tokenIndex894 := position, tokenIndex
+						if buffer[position] != rune(',') {
+							goto l894
+						}
 						position++
 						{
-							position895, tokenIndex895 := position, tokenIndex
+							position896, tokenIndex896 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l895
+								goto l896
 							}
-							goto l896
-						l895:
-							position, tokenIndex = position895, tokenIndex895
+							goto l897
+						l896:
+							position, tokenIndex = position896, tokenIndex896
 						}
-					l896:
+					l897:
 						if !_rules[ruleARMConstantTweak]() {
-							goto l893
+							goto l894
 						}
-						goto l894
-					l893:
-						position, tokenIndex = position893, tokenIndex893
+						goto l895
+					l894:
+						position, tokenIndex = position894, tokenIndex894
 					}
-				l894:
-					goto l871
-				l870:
-					position, tokenIndex = position870, tokenIndex870
+				l895:
+					goto l872
+				l871:
+					position, tokenIndex = position871, tokenIndex871
 				}
-			l871:
+			l872:
 				if buffer[position] != rune(']') {
-					goto l868
+					goto l869
 				}
 				position++
 				{
-					position897, tokenIndex897 := position, tokenIndex
+					position898, tokenIndex898 := position, tokenIndex
 					if !_rules[ruleARMPostincrement]() {
-						goto l897
+						goto l898
 					}
-					goto l898
-				l897:
-					position, tokenIndex = position897, tokenIndex897
+					goto l899
+				l898:
+					position, tokenIndex = position898, tokenIndex898
 				}
-			l898:
-				add(ruleARMBaseIndexScale, position869)
+			l899:
+				add(ruleARMBaseIndexScale, position870)
 			}
 			return true
-		l868:
-			position, tokenIndex = position868, tokenIndex868
+		l869:
+			position, tokenIndex = position869, tokenIndex869
 			return false
 		},
 		/* 54 ARMGOTLow12 <- <(':' ('g' / 'G') ('o' / 'O') ('t' / 'T') '_' ('l' / 'L') ('o' / 'O') '1' '2' ':' SymbolName)> */
 		func() bool {
-			position899, tokenIndex899 := position, tokenIndex
+			position900, tokenIndex900 := position, tokenIndex
 			{
-				position900 := position
+				position901 := position
 				if buffer[position] != rune(':') {
-					goto l899
+					goto l900
 				}
 				position++
 				{
-					position901, tokenIndex901 := position, tokenIndex
+					position902, tokenIndex902 := position, tokenIndex
 					if buffer[position] != rune('g') {
-						goto l902
+						goto l903
 					}
 					position++
-					goto l901
-				l902:
-					position, tokenIndex = position901, tokenIndex901
+					goto l902
+				l903:
+					position, tokenIndex = position902, tokenIndex902
 					if buffer[position] != rune('G') {
-						goto l899
+						goto l900
 					}
 					position++
 				}
-			l901:
+			l902:
 				{
-					position903, tokenIndex903 := position, tokenIndex
+					position904, tokenIndex904 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l904
+						goto l905
 					}
 					position++
-					goto l903
-				l904:
-					position, tokenIndex = position903, tokenIndex903
+					goto l904
+				l905:
+					position, tokenIndex = position904, tokenIndex904
 					if buffer[position] != rune('O') {
-						goto l899
+						goto l900
 					}
 					position++
 				}
-			l903:
+			l904:
 				{
-					position905, tokenIndex905 := position, tokenIndex
+					position906, tokenIndex906 := position, tokenIndex
 					if buffer[position] != rune('t') {
-						goto l906
+						goto l907
 					}
 					position++
-					goto l905
-				l906:
-					position, tokenIndex = position905, tokenIndex905
+					goto l906
+				l907:
+					position, tokenIndex = position906, tokenIndex906
 					if buffer[position] != rune('T') {
-						goto l899
+						goto l900
 					}
 					position++
 				}
-			l905:
+			l906:
 				if buffer[position] != rune('_') {
-					goto l899
+					goto l900
 				}
 				position++
 				{
-					position907, tokenIndex907 := position, tokenIndex
+					position908, tokenIndex908 := position, tokenIndex
 					if buffer[position] != rune('l') {
-						goto l908
+						goto l909
 					}
 					position++
-					goto l907
-				l908:
-					position, tokenIndex = position907, tokenIndex907
+					goto l908
+				l909:
+					position, tokenIndex = position908, tokenIndex908
 					if buffer[position] != rune('L') {
-						goto l899
+						goto l900
 					}
 					position++
 				}
-			l907:
+			l908:
 				{
-					position909, tokenIndex909 := position, tokenIndex
+					position910, tokenIndex910 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l910
+						goto l911
 					}
 					position++
-					goto l909
-				l910:
-					position, tokenIndex = position909, tokenIndex909
+					goto l910
+				l911:
+					position, tokenIndex = position910, tokenIndex910
 					if buffer[position] != rune('O') {
-						goto l899
+						goto l900
 					}
 					position++
 				}
-			l909:
+			l910:
 				if buffer[position] != rune('1') {
-					goto l899
+					goto l900
 				}
 				position++
 				if buffer[position] != rune('2') {
-					goto l899
+					goto l900
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l899
+					goto l900
 				}
 				position++
 				if !_rules[ruleSymbolName]() {
-					goto l899
+					goto l900
 				}
-				add(ruleARMGOTLow12, position900)
+				add(ruleARMGOTLow12, position901)
 			}
 			return true
-		l899:
-			position, tokenIndex = position899, tokenIndex899
+		l900:
+			position, tokenIndex = position900, tokenIndex900
 			return false
 		},
 		/* 55 ARMPostincrement <- <'!'> */
 		func() bool {
-			position911, tokenIndex911 := position, tokenIndex
+			position912, tokenIndex912 := position, tokenIndex
 			{
-				position912 := position
+				position913 := position
 				if buffer[position] != rune('!') {
-					goto l911
+					goto l912
 				}
 				position++
-				add(ruleARMPostincrement, position912)
+				add(ruleARMPostincrement, position913)
 			}
 			return true
-		l911:
-			position, tokenIndex = position911, tokenIndex911
+		l912:
+			position, tokenIndex = position912, tokenIndex912
 			return false
 		},
 		/* 56 BaseIndexScale <- <('(' RegisterOrConstant? WS? (',' WS? RegisterOrConstant WS? (',' [0-9]+)?)? ')')> */
 		func() bool {
-			position913, tokenIndex913 := position, tokenIndex
+			position914, tokenIndex914 := position, tokenIndex
 			{
-				position914 := position
+				position915 := position
 				if buffer[position] != rune('(') {
-					goto l913
+					goto l914
 				}
 				position++
 				{
-					position915, tokenIndex915 := position, tokenIndex
+					position916, tokenIndex916 := position, tokenIndex
 					if !_rules[ruleRegisterOrConstant]() {
-						goto l915
+						goto l916
 					}
-					goto l916
-				l915:
-					position, tokenIndex = position915, tokenIndex915
+					goto l917
+				l916:
+					position, tokenIndex = position916, tokenIndex916
 				}
-			l916:
+			l917:
 				{
-					position917, tokenIndex917 := position, tokenIndex
+					position918, tokenIndex918 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l917
+						goto l918
 					}
-					goto l918
-				l917:
-					position, tokenIndex = position917, tokenIndex917
+					goto l919
+				l918:
+					position, tokenIndex = position918, tokenIndex918
 				}
-			l918:
+			l919:
 				{
-					position919, tokenIndex919 := position, tokenIndex
+					position920, tokenIndex920 := position, tokenIndex
 					if buffer[position] != rune(',') {
-						goto l919
+						goto l920
 					}
 					position++
 					{
-						position921, tokenIndex921 := position, tokenIndex
+						position922, tokenIndex922 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l921
+							goto l922
 						}
-						goto l922
-					l921:
-						position, tokenIndex = position921, tokenIndex921
+						goto l923
+					l922:
+						position, tokenIndex = position922, tokenIndex922
 					}
-				l922:
+				l923:
 					if !_rules[ruleRegisterOrConstant]() {
-						goto l919
+						goto l920
 					}
 					{
-						position923, tokenIndex923 := position, tokenIndex
+						position924, tokenIndex924 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l923
+							goto l924
 						}
-						goto l924
-					l923:
-						position, tokenIndex = position923, tokenIndex923
+						goto l925
+					l924:
+						position, tokenIndex = position924, tokenIndex924
 					}
-				l924:
+				l925:
 					{
-						position925, tokenIndex925 := position, tokenIndex
+						position926, tokenIndex926 := position, tokenIndex
 						if buffer[position] != rune(',') {
-							goto l925
+							goto l926
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l925
+							goto l926
 						}
 						position++
-					l927:
+					l928:
 						{
-							position928, tokenIndex928 := position, tokenIndex
+							position929, tokenIndex929 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l928
+								goto l929
 							}
 							position++
-							goto l927
-						l928:
-							position, tokenIndex = position928, tokenIndex928
+							goto l928
+						l929:
+							position, tokenIndex = position929, tokenIndex929
 						}
-						goto l926
-					l925:
-						position, tokenIndex = position925, tokenIndex925
+						goto l927
+					l926:
+						position, tokenIndex = position926, tokenIndex926
 					}
-				l926:
-					goto l920
-				l919:
-					position, tokenIndex = position919, tokenIndex919
+				l927:
+					goto l921
+				l920:
+					position, tokenIndex = position920, tokenIndex920
 				}
-			l920:
+			l921:
 				if buffer[position] != rune(')') {
-					goto l913
+					goto l914
 				}
 				position++
-				add(ruleBaseIndexScale, position914)
+				add(ruleBaseIndexScale, position915)
 			}
 			return true
-		l913:
-			position, tokenIndex = position913, tokenIndex913
+		l914:
+			position, tokenIndex = position914, tokenIndex914
 			return false
 		},
 		/* 57 Operator <- <('+' / '-')> */
 		func() bool {
-			position929, tokenIndex929 := position, tokenIndex
+			position930, tokenIndex930 := position, tokenIndex
 			{
-				position930 := position
+				position931 := position
 				{
-					position931, tokenIndex931 := position, tokenIndex
+					position932, tokenIndex932 := position, tokenIndex
 					if buffer[position] != rune('+') {
-						goto l932
+						goto l933
 					}
 					position++
-					goto l931
-				l932:
-					position, tokenIndex = position931, tokenIndex931
+					goto l932
+				l933:
+					position, tokenIndex = position932, tokenIndex932
 					if buffer[position] != rune('-') {
-						goto l929
+						goto l930
 					}
 					position++
 				}
-			l931:
-				add(ruleOperator, position930)
+			l932:
+				add(ruleOperator, position931)
 			}
 			return true
-		l929:
-			position, tokenIndex = position929, tokenIndex929
+		l930:
+			position, tokenIndex = position930, tokenIndex930
 			return false
 		},
 		/* 58 Offset <- <('+'? '-'? (('0' ('b' / 'B') ('0' / '1')+) / ('0' ('x' / 'X') ([0-9] / [0-9] / ([a-f] / [A-F]))+) / [0-9]+))> */
 		func() bool {
-			position933, tokenIndex933 := position, tokenIndex
+			position934, tokenIndex934 := position, tokenIndex
 			{
-				position934 := position
+				position935 := position
 				{
-					position935, tokenIndex935 := position, tokenIndex
+					position936, tokenIndex936 := position, tokenIndex
 					if buffer[position] != rune('+') {
-						goto l935
+						goto l936
 					}
 					position++
-					goto l936
-				l935:
-					position, tokenIndex = position935, tokenIndex935
+					goto l937
+				l936:
+					position, tokenIndex = position936, tokenIndex936
 				}
-			l936:
+			l937:
 				{
-					position937, tokenIndex937 := position, tokenIndex
+					position938, tokenIndex938 := position, tokenIndex
 					if buffer[position] != rune('-') {
-						goto l937
+						goto l938
 					}
 					position++
-					goto l938
-				l937:
-					position, tokenIndex = position937, tokenIndex937
+					goto l939
+				l938:
+					position, tokenIndex = position938, tokenIndex938
 				}
-			l938:
+			l939:
 				{
-					position939, tokenIndex939 := position, tokenIndex
+					position940, tokenIndex940 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l940
+						goto l941
 					}
 					position++
 					{
-						position941, tokenIndex941 := position, tokenIndex
+						position942, tokenIndex942 := position, tokenIndex
 						if buffer[position] != rune('b') {
-							goto l942
+							goto l943
 						}
 						position++
-						goto l941
-					l942:
-						position, tokenIndex = position941, tokenIndex941
+						goto l942
+					l943:
+						position, tokenIndex = position942, tokenIndex942
 						if buffer[position] != rune('B') {
-							goto l940
+							goto l941
 						}
 						position++
 					}
-				l941:
+				l942:
+					{
+						position946, tokenIndex946 := position, tokenIndex
+						if buffer[position] != rune('0') {
+							goto l947
+						}
+						position++
+						goto l946
+					l947:
+						position, tokenIndex = position946, tokenIndex946
+						if buffer[position] != rune('1') {
+							goto l941
+						}
+						position++
+					}
+				l946:
+				l944:
 					{
 						position945, tokenIndex945 := position, tokenIndex
-						if buffer[position] != rune('0') {
-							goto l946
-						}
-						position++
-						goto l945
-					l946:
-						position, tokenIndex = position945, tokenIndex945
-						if buffer[position] != rune('1') {
-							goto l940
-						}
-						position++
-					}
-				l945:
-				l943:
-					{
-						position944, tokenIndex944 := position, tokenIndex
 						{
-							position947, tokenIndex947 := position, tokenIndex
+							position948, tokenIndex948 := position, tokenIndex
 							if buffer[position] != rune('0') {
-								goto l948
+								goto l949
 							}
 							position++
-							goto l947
-						l948:
-							position, tokenIndex = position947, tokenIndex947
+							goto l948
+						l949:
+							position, tokenIndex = position948, tokenIndex948
 							if buffer[position] != rune('1') {
-								goto l944
+								goto l945
 							}
 							position++
 						}
-					l947:
-						goto l943
-					l944:
-						position, tokenIndex = position944, tokenIndex944
+					l948:
+						goto l944
+					l945:
+						position, tokenIndex = position945, tokenIndex945
 					}
-					goto l939
-				l940:
-					position, tokenIndex = position939, tokenIndex939
+					goto l940
+				l941:
+					position, tokenIndex = position940, tokenIndex940
 					if buffer[position] != rune('0') {
-						goto l949
+						goto l950
 					}
 					position++
 					{
-						position950, tokenIndex950 := position, tokenIndex
+						position951, tokenIndex951 := position, tokenIndex
 						if buffer[position] != rune('x') {
-							goto l951
+							goto l952
 						}
 						position++
-						goto l950
-					l951:
-						position, tokenIndex = position950, tokenIndex950
+						goto l951
+					l952:
+						position, tokenIndex = position951, tokenIndex951
 						if buffer[position] != rune('X') {
-							goto l949
+							goto l950
 						}
 						position++
 					}
-				l950:
+				l951:
 					{
-						position954, tokenIndex954 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l955
-						}
-						position++
-						goto l954
-					l955:
-						position, tokenIndex = position954, tokenIndex954
+						position955, tokenIndex955 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
 							goto l956
 						}
 						position++
-						goto l954
+						goto l955
 					l956:
-						position, tokenIndex = position954, tokenIndex954
+						position, tokenIndex = position955, tokenIndex955
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l957
+						}
+						position++
+						goto l955
+					l957:
+						position, tokenIndex = position955, tokenIndex955
 						{
-							position957, tokenIndex957 := position, tokenIndex
+							position958, tokenIndex958 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('f') {
-								goto l958
+								goto l959
 							}
 							position++
-							goto l957
-						l958:
-							position, tokenIndex = position957, tokenIndex957
+							goto l958
+						l959:
+							position, tokenIndex = position958, tokenIndex958
 							if c := buffer[position]; c < rune('A') || c > rune('F') {
-								goto l949
+								goto l950
 							}
 							position++
 						}
-					l957:
+					l958:
 					}
-				l954:
-				l952:
+				l955:
+				l953:
 					{
-						position953, tokenIndex953 := position, tokenIndex
+						position954, tokenIndex954 := position, tokenIndex
 						{
-							position959, tokenIndex959 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l960
-							}
-							position++
-							goto l959
-						l960:
-							position, tokenIndex = position959, tokenIndex959
+							position960, tokenIndex960 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
 								goto l961
 							}
 							position++
-							goto l959
+							goto l960
 						l961:
-							position, tokenIndex = position959, tokenIndex959
+							position, tokenIndex = position960, tokenIndex960
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l962
+							}
+							position++
+							goto l960
+						l962:
+							position, tokenIndex = position960, tokenIndex960
 							{
-								position962, tokenIndex962 := position, tokenIndex
+								position963, tokenIndex963 := position, tokenIndex
 								if c := buffer[position]; c < rune('a') || c > rune('f') {
-									goto l963
+									goto l964
 								}
 								position++
-								goto l962
-							l963:
-								position, tokenIndex = position962, tokenIndex962
+								goto l963
+							l964:
+								position, tokenIndex = position963, tokenIndex963
 								if c := buffer[position]; c < rune('A') || c > rune('F') {
-									goto l953
+									goto l954
 								}
 								position++
 							}
-						l962:
+						l963:
 						}
-					l959:
-						goto l952
-					l953:
-						position, tokenIndex = position953, tokenIndex953
+					l960:
+						goto l953
+					l954:
+						position, tokenIndex = position954, tokenIndex954
 					}
-					goto l939
-				l949:
-					position, tokenIndex = position939, tokenIndex939
+					goto l940
+				l950:
+					position, tokenIndex = position940, tokenIndex940
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l933
+						goto l934
 					}
 					position++
-				l964:
+				l965:
 					{
-						position965, tokenIndex965 := position, tokenIndex
+						position966, tokenIndex966 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l965
+							goto l966
 						}
 						position++
-						goto l964
-					l965:
-						position, tokenIndex = position965, tokenIndex965
+						goto l965
+					l966:
+						position, tokenIndex = position966, tokenIndex966
 					}
 				}
-			l939:
-				add(ruleOffset, position934)
+			l940:
+				add(ruleOffset, position935)
 			}
 			return true
-		l933:
-			position, tokenIndex = position933, tokenIndex933
+		l934:
+			position, tokenIndex = position934, tokenIndex934
 			return false
 		},
 		/* 59 Section <- <([a-z] / [A-Z] / '@')+> */
 		func() bool {
-			position966, tokenIndex966 := position, tokenIndex
+			position967, tokenIndex967 := position, tokenIndex
 			{
-				position967 := position
+				position968 := position
 				{
-					position970, tokenIndex970 := position, tokenIndex
+					position971, tokenIndex971 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l971
-					}
-					position++
-					goto l970
-				l971:
-					position, tokenIndex = position970, tokenIndex970
-					if c := buffer[position]; c < rune('A') || c > rune('Z') {
 						goto l972
 					}
 					position++
-					goto l970
+					goto l971
 				l972:
-					position, tokenIndex = position970, tokenIndex970
+					position, tokenIndex = position971, tokenIndex971
+					if c := buffer[position]; c < rune('A') || c > rune('Z') {
+						goto l973
+					}
+					position++
+					goto l971
+				l973:
+					position, tokenIndex = position971, tokenIndex971
 					if buffer[position] != rune('@') {
-						goto l966
+						goto l967
 					}
 					position++
 				}
-			l970:
-			l968:
+			l971:
+			l969:
 				{
-					position969, tokenIndex969 := position, tokenIndex
+					position970, tokenIndex970 := position, tokenIndex
 					{
-						position973, tokenIndex973 := position, tokenIndex
+						position974, tokenIndex974 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l974
-						}
-						position++
-						goto l973
-					l974:
-						position, tokenIndex = position973, tokenIndex973
-						if c := buffer[position]; c < rune('A') || c > rune('Z') {
 							goto l975
 						}
 						position++
-						goto l973
+						goto l974
 					l975:
-						position, tokenIndex = position973, tokenIndex973
+						position, tokenIndex = position974, tokenIndex974
+						if c := buffer[position]; c < rune('A') || c > rune('Z') {
+							goto l976
+						}
+						position++
+						goto l974
+					l976:
+						position, tokenIndex = position974, tokenIndex974
 						if buffer[position] != rune('@') {
-							goto l969
+							goto l970
 						}
 						position++
 					}
-				l973:
-					goto l968
-				l969:
-					position, tokenIndex = position969, tokenIndex969
+				l974:
+					goto l969
+				l970:
+					position, tokenIndex = position970, tokenIndex970
 				}
-				add(ruleSection, position967)
+				add(ruleSection, position968)
 			}
 			return true
-		l966:
-			position, tokenIndex = position966, tokenIndex966
+		l967:
+			position, tokenIndex = position967, tokenIndex967
 			return false
 		},
 		/* 60 SegmentRegister <- <('%' ([c-g] / 's') ('s' ':'))> */
 		func() bool {
-			position976, tokenIndex976 := position, tokenIndex
+			position977, tokenIndex977 := position, tokenIndex
 			{
-				position977 := position
+				position978 := position
 				if buffer[position] != rune('%') {
-					goto l976
+					goto l977
 				}
 				position++
 				{
-					position978, tokenIndex978 := position, tokenIndex
+					position979, tokenIndex979 := position, tokenIndex
 					if c := buffer[position]; c < rune('c') || c > rune('g') {
-						goto l979
+						goto l980
 					}
 					position++
-					goto l978
-				l979:
-					position, tokenIndex = position978, tokenIndex978
+					goto l979
+				l980:
+					position, tokenIndex = position979, tokenIndex979
 					if buffer[position] != rune('s') {
-						goto l976
+						goto l977
 					}
 					position++
 				}
-			l978:
+			l979:
 				if buffer[position] != rune('s') {
-					goto l976
+					goto l977
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l976
+					goto l977
 				}
 				position++
-				add(ruleSegmentRegister, position977)
+				add(ruleSegmentRegister, position978)
 			}
 			return true
-		l976:
-			position, tokenIndex = position976, tokenIndex976
+		l977:
+			position, tokenIndex = position977, tokenIndex977
 			return false
 		},
 	}
diff --git a/util/fipstools/test_fips.cc b/util/fipstools/test_fips.cc
index 2411248..68024b6 100644
--- a/util/fipstools/test_fips.cc
+++ b/util/fipstools/test_fips.cc
@@ -20,6 +20,7 @@
 #include <openssl/aead.h>
 #include <openssl/aes.h>
 #include <openssl/bn.h>
+#include <openssl/bytestring.h>
 #include <openssl/crypto.h>
 #include <openssl/ctrdrbg.h>
 #include <openssl/des.h>
@@ -33,6 +34,7 @@
 #include <openssl/rsa.h>
 #include <openssl/sha.h>
 
+#include "../../crypto/fipsmodule/bcm_interface.h"
 #include "../../crypto/fipsmodule/rand/internal.h"
 #include "../../crypto/fipsmodule/tls/internal.h"
 #include "../../crypto/internal.h"
@@ -406,6 +408,44 @@
   printf("  got ");
   hexdump(dh_result, sizeof(dh_result));
 
+  /* ML-KEM */
+  printf("About to generate ML-KEM key:\n");
+  auto mlkem_public_key_bytes =
+      std::make_unique<uint8_t[]>(BCM_MLKEM768_PUBLIC_KEY_BYTES);
+  auto mlkem_private_key = std::make_unique<BCM_mlkem768_private_key>();
+  if (BCM_mlkem768_generate_key_fips(mlkem_public_key_bytes.get(), nullptr,
+                                     mlkem_private_key.get()) !=
+      bcm_status::approved) {
+    fprintf(stderr, "ML-KEM generation failed");
+    return 0;
+  }
+  printf("  got ");
+  hexdump(mlkem_public_key_bytes.get(), BCM_MLKEM768_PUBLIC_KEY_BYTES);
+
+  printf("About to do ML-KEM encap:\n");
+  auto mlkem_ciphertext = std::make_unique<uint8_t[]>(BCM_MLKEM768_CIPHERTEXT_BYTES);
+  uint8_t mlkem_shared_secret[BCM_MLKEM_SHARED_SECRET_BYTES];
+  auto mlkem_public_key = std::make_unique<BCM_mlkem768_public_key>();
+  BCM_mlkem768_public_from_private(mlkem_public_key.get(),
+                                   mlkem_private_key.get());
+  if (BCM_mlkem768_encap(mlkem_ciphertext.get(), mlkem_shared_secret,
+                         mlkem_public_key.get()) != bcm_infallible::approved) {
+    fprintf(stderr, "ML-KEM encap failed");
+    return 0;
+  }
+  printf("  got ");
+  hexdump(mlkem_shared_secret, sizeof(mlkem_shared_secret));
+
+  printf("About to do ML-KEM decap:\n");
+  if (BCM_mlkem768_decap(mlkem_shared_secret, mlkem_ciphertext.get(),
+                         BCM_MLKEM768_CIPHERTEXT_BYTES,
+                         mlkem_private_key.get()) != bcm_status::approved) {
+    fprintf(stderr, "ML-KEM decap failed");
+    return 0;
+  }
+  printf("  got ");
+  hexdump(mlkem_shared_secret, sizeof(mlkem_shared_secret));
+
   printf("PASS\n");
   return 1;
 #endif  // !defined(BORINGSSL_FIPS)