diff --git a/util/fipstools/delocate/delocate.go b/util/fipstools/delocate/delocate.go
index f8573e3055..6c63c6cc26 100644
--- a/util/fipstools/delocate/delocate.go
+++ b/util/fipstools/delocate/delocate.go
@@ -300,6 +300,47 @@ func (d *delocation) processDirective(statement, directive *node32) (*node32, er
 	return statement, nil
 }
 
+func (d *delocation) processSymbolExpr(expr *node32, b *strings.Builder) bool {
+	changed := false
+	assertNodeType(expr, ruleSymbolExpr)
+
+	for expr != nil {
+		atom := expr.up
+		assertNodeType(atom, ruleSymbolAtom)
+
+		for term := atom.up; term != nil; term = skipWS(term.next) {
+			if term.pegRule == ruleSymbolExpr {
+				changed = d.processSymbolExpr(term, b) || changed
+				continue
+			}
+
+			if term.pegRule != ruleLocalSymbol {
+				b.WriteString(d.contents(term))
+				continue
+			}
+
+			oldSymbol := d.contents(term)
+			newSymbol := d.mapLocalSymbol(oldSymbol)
+			if newSymbol != oldSymbol {
+				changed = true
+			}
+
+			b.WriteString(newSymbol)
+		}
+
+		next := skipWS(atom.next)
+		if next == nil {
+			break
+		}
+		assertNodeType(next, ruleSymbolOperator)
+		b.WriteString(d.contents(next))
+		next = skipWS(next.next)
+		assertNodeType(next, ruleSymbolExpr)
+		expr = next
+	}
+	return changed
+}
+
 func (d *delocation) processLabelContainingDirective(statement, directive *node32) (*node32, error) {
 	// The symbols within directives need to be mapped so that local
 	// symbols in two different .s inputs don't collide.
@@ -317,24 +358,12 @@ func (d *delocation) processLabelContainingDirective(statement, directive *node3
 	for node = skipWS(node.up); node != nil; node = skipWS(node.next) {
 		assertNodeType(node, ruleSymbolArg)
 		arg := node.up
-		var mapped string
+		assertNodeType(arg, ruleSymbolExpr)
 
-		for term := arg; term != nil; term = term.next {
-			if term.pegRule != ruleLocalSymbol {
-				mapped += d.contents(term)
-				continue
-			}
-
-			oldSymbol := d.contents(term)
-			newSymbol := d.mapLocalSymbol(oldSymbol)
-			if newSymbol != oldSymbol {
-				changed = true
-			}
-
-			mapped += newSymbol
-		}
+		var b strings.Builder
+		changed = d.processSymbolExpr(arg, &b) || changed
 
-		args = append(args, mapped)
+		args = append(args, b.String())
 	}
 
 	if !changed {
@@ -1722,6 +1751,16 @@ func writeAarch64Function(w stringWriter, funcName string, writeContents func(st
 	w.WriteString(".type " + funcName + ", @function\n")
 	w.WriteString(funcName + ":\n")
 	w.WriteString(".cfi_startproc\n")
+	// We insert a landing pad (`bti c` instruction) unconditionally at the beginning of
+	// every generated function so that they can be called indirectly (with `blr` or
+	// `br x16/x17`). The instruction is encoded in the HINT space as `hint #34` and is
+	// a no-op on machines or program states not supporting BTI (Branch Target Identification).
+	// None of the generated function bodies call other functions (with bl or blr), so we only
+	// insert a landing pad instead of signing and validating $lr with `paciasp` and `autiasp`.
+	// Normally we would also generate a .note.gnu.property section to annotate the assembly
+	// file as BTI-compatible, but if the input assembly files are BTI-compatible, they should
+	// already have those sections so there is no need to add an extra one ourselves.
+	w.WriteString("\thint #34 // bti c\n")
 	writeContents(w)
 	w.WriteString(".cfi_endproc\n")
 	w.WriteString(".size " + funcName + ", .-" + funcName + "\n")
diff --git a/util/fipstools/delocate/delocate.peg b/util/fipstools/delocate/delocate.peg
index 8900af05cc..74f0d7c6c3 100644
--- a/util/fipstools/delocate/delocate.peg
+++ b/util/fipstools/delocate/delocate.peg
@@ -47,18 +47,14 @@ QuotedText <- (EscapedChar / [^"])*
 LabelContainingDirective <- LabelContainingDirectiveName WS SymbolArgs
 LabelContainingDirectiveName <- ".xword" / ".word" / ".long" / ".set" / ".byte" / ".8byte" / ".4byte" / ".quad" / ".tc" / ".localentry" / ".size" / ".type" / ".uleb128" / ".sleb128"
 SymbolArgs <- SymbolArg ((WS? ',' WS?) SymbolArg)*
-SymbolShift <- ('<<' / '>>') WS? [0-9]+
-SymbolArg <- (OpenParen WS?)? (
-               Offset /
-               SymbolType /
-               (Offset / LocalSymbol / SymbolName / Dot) (WS? Operator WS? (Offset / LocalSymbol / SymbolName))* /
-               LocalLabelRef WS? Operator WS? LocalLabelRef /
-               LocalSymbol TCMarker? /
-               SymbolName Offset /
-               SymbolName TCMarker?)
-             (WS? CloseParen)? (WS? SymbolShift)?
+SymbolArg <- SymbolExpr
+SymbolExpr <- SymbolAtom (WS? SymbolOperator WS? SymbolExpr)?
+SymbolAtom <- Offset / SymbolType / LocalSymbol TCMarker? / SymbolName Offset / SymbolName TCMarker? / Dot / OpenParen WS? SymbolExpr WS? CloseParen
+SymbolOperator <- '+' / '-' / '|' / '<<' / '>>'
+
 OpenParen <- '('
 CloseParen <- ')'
+
 SymbolType <- [@%] ('function' / 'object')
 Dot <- '.'
 TCMarker <- '[TC]'
diff --git a/util/fipstools/delocate/delocate.peg.go b/util/fipstools/delocate/delocate.peg.go
index 8a80b35661..3d8ecf6c38 100644
--- a/util/fipstools/delocate/delocate.peg.go
+++ b/util/fipstools/delocate/delocate.peg.go
@@ -1,6 +1,6 @@
 package main
 
-// Code generated by /home/ec2-user/go/bin/peg ./delocate.peg DO NOT EDIT.
+// Code generated by /home/ec2-user/go/bin/peg delocate.peg DO NOT EDIT.
 
 import (
 	"fmt"
@@ -33,8 +33,10 @@ const (
 	ruleLabelContainingDirective
 	ruleLabelContainingDirectiveName
 	ruleSymbolArgs
-	ruleSymbolShift
 	ruleSymbolArg
+	ruleSymbolExpr
+	ruleSymbolAtom
+	ruleSymbolOperator
 	ruleOpenParen
 	ruleCloseParen
 	ruleSymbolType
@@ -92,8 +94,10 @@ var rul3s = [...]string{
 	"LabelContainingDirective",
 	"LabelContainingDirectiveName",
 	"SymbolArgs",
-	"SymbolShift",
 	"SymbolArg",
+	"SymbolExpr",
+	"SymbolAtom",
+	"SymbolOperator",
 	"OpenParen",
 	"CloseParen",
 	"SymbolType",
@@ -246,7 +250,7 @@ func (t *tokens32) Tokens() []token32 {
 type Asm struct {
 	Buffer string
 	buffer []rune
-	rules  [56]func() bool
+	rules  [58]func() bool
 	parse  func(rule ...int) error
 	reset  func()
 	Pretty bool
@@ -2515,37 +2519,55 @@ func (p *Asm) Init(options ...func(*Asm) error) error {
 			position, tokenIndex = position283, tokenIndex283
 			return false
 		},
-		/* 15 SymbolShift <- <((('<' '<') / ('>' '>')) WS? [0-9]+)> */
+		/* 15 SymbolArg <- <SymbolExpr> */
 		func() bool {
 			position291, tokenIndex291 := position, tokenIndex
 			{
 				position292 := position
-				{
-					position293, tokenIndex293 := position, tokenIndex
-					if buffer[position] != rune('<') {
-						goto l294
-					}
-					position++
-					if buffer[position] != rune('<') {
-						goto l294
-					}
-					position++
+				if !_rules[ruleSymbolExpr]() {
+					goto l291
+				}
+				add(ruleSymbolArg, position292)
+			}
+			return true
+		l291:
+			position, tokenIndex = position291, tokenIndex291
+			return false
+		},
+		/* 16 SymbolExpr <- <(SymbolAtom (WS? SymbolOperator WS? SymbolExpr)?)> */
+		func() bool {
+			position293, tokenIndex293 := position, tokenIndex
+			{
+				position294 := position
+				if !_rules[ruleSymbolAtom]() {
 					goto l293
-				l294:
-					position, tokenIndex = position293, tokenIndex293
-					if buffer[position] != rune('>') {
-						goto l291
-					}
-					position++
-					if buffer[position] != rune('>') {
-						goto l291
-					}
-					position++
 				}
-			l293:
 				{
 					position295, tokenIndex295 := position, tokenIndex
-					if !_rules[ruleWS]() {
+					{
+						position297, tokenIndex297 := position, tokenIndex
+						if !_rules[ruleWS]() {
+							goto l297
+						}
+						goto l298
+					l297:
+						position, tokenIndex = position297, tokenIndex297
+					}
+				l298:
+					if !_rules[ruleSymbolOperator]() {
+						goto l295
+					}
+					{
+						position299, tokenIndex299 := position, tokenIndex
+						if !_rules[ruleWS]() {
+							goto l299
+						}
+						goto l300
+					l299:
+						position, tokenIndex = position299, tokenIndex299
+					}
+				l300:
+					if !_rules[ruleSymbolExpr]() {
 						goto l295
 					}
 					goto l296
@@ -2553,4849 +2575,4759 @@ func (p *Asm) Init(options ...func(*Asm) error) error {
 					position, tokenIndex = position295, tokenIndex295
 				}
 			l296:
-				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l291
-				}
-				position++
-			l297:
-				{
-					position298, tokenIndex298 := position, tokenIndex
-					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l298
-					}
-					position++
-					goto l297
-				l298:
-					position, tokenIndex = position298, tokenIndex298
-				}
-				add(ruleSymbolShift, position292)
+				add(ruleSymbolExpr, position294)
 			}
 			return true
-		l291:
-			position, tokenIndex = position291, tokenIndex291
+		l293:
+			position, tokenIndex = position293, tokenIndex293
 			return false
 		},
-		/* 16 SymbolArg <- <((OpenParen WS?)? (Offset / SymbolType / ((Offset / LocalSymbol / SymbolName / Dot) (WS? Operator WS? (Offset / LocalSymbol / SymbolName))*) / (LocalLabelRef WS? Operator WS? LocalLabelRef) / (LocalSymbol TCMarker?) / (SymbolName Offset) / (SymbolName TCMarker?)) (WS? CloseParen)? (WS? SymbolShift)?)> */
+		/* 17 SymbolAtom <- <(Offset / SymbolType / (LocalSymbol TCMarker?) / (SymbolName Offset) / (SymbolName TCMarker?) / Dot / (OpenParen WS? SymbolExpr WS? CloseParen))> */
 		func() bool {
-			position299, tokenIndex299 := position, tokenIndex
+			position301, tokenIndex301 := position, tokenIndex
 			{
-				position300 := position
+				position302 := position
 				{
-					position301, tokenIndex301 := position, tokenIndex
-					if !_rules[ruleOpenParen]() {
-						goto l301
-					}
-					{
-						position303, tokenIndex303 := position, tokenIndex
-						if !_rules[ruleWS]() {
-							goto l303
-						}
+					position303, tokenIndex303 := position, tokenIndex
+					if !_rules[ruleOffset]() {
 						goto l304
-					l303:
-						position, tokenIndex = position303, tokenIndex303
 					}
+					goto l303
 				l304:
-					goto l302
-				l301:
-					position, tokenIndex = position301, tokenIndex301
-				}
-			l302:
-				{
-					position305, tokenIndex305 := position, tokenIndex
-					if !_rules[ruleOffset]() {
-						goto l306
-					}
-					goto l305
-				l306:
-					position, tokenIndex = position305, tokenIndex305
+					position, tokenIndex = position303, tokenIndex303
 					if !_rules[ruleSymbolType]() {
-						goto l307
+						goto l305
+					}
+					goto l303
+				l305:
+					position, tokenIndex = position303, tokenIndex303
+					if !_rules[ruleLocalSymbol]() {
+						goto l306
 					}
-					goto l305
-				l307:
-					position, tokenIndex = position305, tokenIndex305
 					{
-						position309, tokenIndex309 := position, tokenIndex
-						if !_rules[ruleOffset]() {
-							goto l310
+						position307, tokenIndex307 := position, tokenIndex
+						if !_rules[ruleTCMarker]() {
+							goto l307
 						}
+						goto l308
+					l307:
+						position, tokenIndex = position307, tokenIndex307
+					}
+				l308:
+					goto l303
+				l306:
+					position, tokenIndex = position303, tokenIndex303
+					if !_rules[ruleSymbolName]() {
+						goto l309
+					}
+					if !_rules[ruleOffset]() {
 						goto l309
-					l310:
-						position, tokenIndex = position309, tokenIndex309
-						if !_rules[ruleLocalSymbol]() {
+					}
+					goto l303
+				l309:
+					position, tokenIndex = position303, tokenIndex303
+					if !_rules[ruleSymbolName]() {
+						goto l310
+					}
+					{
+						position311, tokenIndex311 := position, tokenIndex
+						if !_rules[ruleTCMarker]() {
 							goto l311
 						}
-						goto l309
+						goto l312
 					l311:
-						position, tokenIndex = position309, tokenIndex309
-						if !_rules[ruleSymbolName]() {
-							goto l312
-						}
-						goto l309
-					l312:
-						position, tokenIndex = position309, tokenIndex309
-						if !_rules[ruleDot]() {
-							goto l308
-						}
+						position, tokenIndex = position311, tokenIndex311
 					}
-				l309:
+				l312:
+					goto l303
+				l310:
+					position, tokenIndex = position303, tokenIndex303
+					if !_rules[ruleDot]() {
+						goto l313
+					}
+					goto l303
 				l313:
+					position, tokenIndex = position303, tokenIndex303
+					if !_rules[ruleOpenParen]() {
+						goto l301
+					}
 					{
 						position314, tokenIndex314 := position, tokenIndex
-						{
-							position315, tokenIndex315 := position, tokenIndex
-							if !_rules[ruleWS]() {
-								goto l315
-							}
-							goto l316
-						l315:
-							position, tokenIndex = position315, tokenIndex315
-						}
-					l316:
-						if !_rules[ruleOperator]() {
+						if !_rules[ruleWS]() {
 							goto l314
 						}
-						{
-							position317, tokenIndex317 := position, tokenIndex
-							if !_rules[ruleWS]() {
-								goto l317
-							}
-							goto l318
-						l317:
-							position, tokenIndex = position317, tokenIndex317
-						}
-					l318:
-						{
-							position319, tokenIndex319 := position, tokenIndex
-							if !_rules[ruleOffset]() {
-								goto l320
-							}
-							goto l319
-						l320:
-							position, tokenIndex = position319, tokenIndex319
-							if !_rules[ruleLocalSymbol]() {
-								goto l321
-							}
-							goto l319
-						l321:
-							position, tokenIndex = position319, tokenIndex319
-							if !_rules[ruleSymbolName]() {
-								goto l314
-							}
-						}
-					l319:
-						goto l313
+						goto l315
 					l314:
 						position, tokenIndex = position314, tokenIndex314
 					}
-					goto l305
-				l308:
-					position, tokenIndex = position305, tokenIndex305
-					if !_rules[ruleLocalLabelRef]() {
-						goto l322
+				l315:
+					if !_rules[ruleSymbolExpr]() {
+						goto l301
 					}
 					{
-						position323, tokenIndex323 := position, tokenIndex
+						position316, tokenIndex316 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l323
+							goto l316
 						}
-						goto l324
-					l323:
-						position, tokenIndex = position323, tokenIndex323
+						goto l317
+					l316:
+						position, tokenIndex = position316, tokenIndex316
 					}
-				l324:
-					if !_rules[ruleOperator]() {
-						goto l322
+				l317:
+					if !_rules[ruleCloseParen]() {
+						goto l301
 					}
-					{
-						position325, tokenIndex325 := position, tokenIndex
-						if !_rules[ruleWS]() {
-							goto l325
-						}
-						goto l326
-					l325:
-						position, tokenIndex = position325, tokenIndex325
+				}
+			l303:
+				add(ruleSymbolAtom, position302)
+			}
+			return true
+		l301:
+			position, tokenIndex = position301, tokenIndex301
+			return false
+		},
+		/* 18 SymbolOperator <- <('+' / '-' / '|' / ('<' '<') / ('>' '>'))> */
+		func() bool {
+			position318, tokenIndex318 := position, tokenIndex
+			{
+				position319 := position
+				{
+					position320, tokenIndex320 := position, tokenIndex
+					if buffer[position] != rune('+') {
+						goto l321
 					}
-				l326:
-					if !_rules[ruleLocalLabelRef]() {
+					position++
+					goto l320
+				l321:
+					position, tokenIndex = position320, tokenIndex320
+					if buffer[position] != rune('-') {
 						goto l322
 					}
-					goto l305
+					position++
+					goto l320
 				l322:
-					position, tokenIndex = position305, tokenIndex305
-					if !_rules[ruleLocalSymbol]() {
-						goto l327
-					}
-					{
-						position328, tokenIndex328 := position, tokenIndex
-						if !_rules[ruleTCMarker]() {
-							goto l328
-						}
-						goto l329
-					l328:
-						position, tokenIndex = position328, tokenIndex328
-					}
-				l329:
-					goto l305
-				l327:
-					position, tokenIndex = position305, tokenIndex305
-					if !_rules[ruleSymbolName]() {
-						goto l330
-					}
-					if !_rules[ruleOffset]() {
-						goto l330
+					position, tokenIndex = position320, tokenIndex320
+					if buffer[position] != rune('|') {
+						goto l323
 					}
-					goto l305
-				l330:
-					position, tokenIndex = position305, tokenIndex305
-					if !_rules[ruleSymbolName]() {
-						goto l299
-					}
-					{
-						position331, tokenIndex331 := position, tokenIndex
-						if !_rules[ruleTCMarker]() {
-							goto l331
-						}
-						goto l332
-					l331:
-						position, tokenIndex = position331, tokenIndex331
-					}
-				l332:
-				}
-			l305:
-				{
-					position333, tokenIndex333 := position, tokenIndex
-					{
-						position335, tokenIndex335 := position, tokenIndex
-						if !_rules[ruleWS]() {
-							goto l335
-						}
-						goto l336
-					l335:
-						position, tokenIndex = position335, tokenIndex335
+					position++
+					goto l320
+				l323:
+					position, tokenIndex = position320, tokenIndex320
+					if buffer[position] != rune('<') {
+						goto l324
 					}
-				l336:
-					if !_rules[ruleCloseParen]() {
-						goto l333
+					position++
+					if buffer[position] != rune('<') {
+						goto l324
 					}
-					goto l334
-				l333:
-					position, tokenIndex = position333, tokenIndex333
-				}
-			l334:
-				{
-					position337, tokenIndex337 := position, tokenIndex
-					{
-						position339, tokenIndex339 := position, tokenIndex
-						if !_rules[ruleWS]() {
-							goto l339
-						}
-						goto l340
-					l339:
-						position, tokenIndex = position339, tokenIndex339
+					position++
+					goto l320
+				l324:
+					position, tokenIndex = position320, tokenIndex320
+					if buffer[position] != rune('>') {
+						goto l318
 					}
-				l340:
-					if !_rules[ruleSymbolShift]() {
-						goto l337
+					position++
+					if buffer[position] != rune('>') {
+						goto l318
 					}
-					goto l338
-				l337:
-					position, tokenIndex = position337, tokenIndex337
+					position++
 				}
-			l338:
-				add(ruleSymbolArg, position300)
+			l320:
+				add(ruleSymbolOperator, position319)
 			}
 			return true
-		l299:
-			position, tokenIndex = position299, tokenIndex299
+		l318:
+			position, tokenIndex = position318, tokenIndex318
 			return false
 		},
-		/* 17 OpenParen <- <'('> */
+		/* 19 OpenParen <- <'('> */
 		func() bool {
-			position341, tokenIndex341 := position, tokenIndex
+			position325, tokenIndex325 := position, tokenIndex
 			{
-				position342 := position
+				position326 := position
 				if buffer[position] != rune('(') {
-					goto l341
+					goto l325
 				}
 				position++
-				add(ruleOpenParen, position342)
+				add(ruleOpenParen, position326)
 			}
 			return true
-		l341:
-			position, tokenIndex = position341, tokenIndex341
+		l325:
+			position, tokenIndex = position325, tokenIndex325
 			return false
 		},
-		/* 18 CloseParen <- <')'> */
+		/* 20 CloseParen <- <')'> */
 		func() bool {
-			position343, tokenIndex343 := position, tokenIndex
+			position327, tokenIndex327 := position, tokenIndex
 			{
-				position344 := position
+				position328 := position
 				if buffer[position] != rune(')') {
-					goto l343
+					goto l327
 				}
 				position++
-				add(ruleCloseParen, position344)
+				add(ruleCloseParen, position328)
 			}
 			return true
-		l343:
-			position, tokenIndex = position343, tokenIndex343
+		l327:
+			position, tokenIndex = position327, tokenIndex327
 			return false
 		},
-		/* 19 SymbolType <- <(('@' / '%') (('f' 'u' 'n' 'c' 't' 'i' 'o' 'n') / ('o' 'b' 'j' 'e' 'c' 't')))> */
+		/* 21 SymbolType <- <(('@' / '%') (('f' 'u' 'n' 'c' 't' 'i' 'o' 'n') / ('o' 'b' 'j' 'e' 'c' 't')))> */
 		func() bool {
-			position345, tokenIndex345 := position, tokenIndex
+			position329, tokenIndex329 := position, tokenIndex
 			{
-				position346 := position
+				position330 := position
 				{
-					position347, tokenIndex347 := position, tokenIndex
+					position331, tokenIndex331 := position, tokenIndex
 					if buffer[position] != rune('@') {
-						goto l348
+						goto l332
 					}
 					position++
-					goto l347
-				l348:
-					position, tokenIndex = position347, tokenIndex347
+					goto l331
+				l332:
+					position, tokenIndex = position331, tokenIndex331
 					if buffer[position] != rune('%') {
-						goto l345
+						goto l329
 					}
 					position++
 				}
-			l347:
+			l331:
 				{
-					position349, tokenIndex349 := position, tokenIndex
+					position333, tokenIndex333 := position, tokenIndex
 					if buffer[position] != rune('f') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('u') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('n') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('c') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('t') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('i') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('o') {
-						goto l350
+						goto l334
 					}
 					position++
 					if buffer[position] != rune('n') {
-						goto l350
+						goto l334
 					}
 					position++
-					goto l349
-				l350:
-					position, tokenIndex = position349, tokenIndex349
+					goto l333
+				l334:
+					position, tokenIndex = position333, tokenIndex333
 					if buffer[position] != rune('o') {
-						goto l345
+						goto l329
 					}
 					position++
 					if buffer[position] != rune('b') {
-						goto l345
+						goto l329
 					}
 					position++
 					if buffer[position] != rune('j') {
-						goto l345
+						goto l329
 					}
 					position++
 					if buffer[position] != rune('e') {
-						goto l345
+						goto l329
 					}
 					position++
 					if buffer[position] != rune('c') {
-						goto l345
+						goto l329
 					}
 					position++
 					if buffer[position] != rune('t') {
-						goto l345
+						goto l329
 					}
 					position++
 				}
-			l349:
-				add(ruleSymbolType, position346)
+			l333:
+				add(ruleSymbolType, position330)
 			}
 			return true
-		l345:
-			position, tokenIndex = position345, tokenIndex345
+		l329:
+			position, tokenIndex = position329, tokenIndex329
 			return false
 		},
-		/* 20 Dot <- <'.'> */
+		/* 22 Dot <- <'.'> */
 		func() bool {
-			position351, tokenIndex351 := position, tokenIndex
+			position335, tokenIndex335 := position, tokenIndex
 			{
-				position352 := position
+				position336 := position
 				if buffer[position] != rune('.') {
-					goto l351
+					goto l335
 				}
 				position++
-				add(ruleDot, position352)
+				add(ruleDot, position336)
 			}
 			return true
-		l351:
-			position, tokenIndex = position351, tokenIndex351
+		l335:
+			position, tokenIndex = position335, tokenIndex335
 			return false
 		},
-		/* 21 TCMarker <- <('[' 'T' 'C' ']')> */
+		/* 23 TCMarker <- <('[' 'T' 'C' ']')> */
 		func() bool {
-			position353, tokenIndex353 := position, tokenIndex
+			position337, tokenIndex337 := position, tokenIndex
 			{
-				position354 := position
+				position338 := position
 				if buffer[position] != rune('[') {
-					goto l353
+					goto l337
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l353
+					goto l337
 				}
 				position++
 				if buffer[position] != rune('C') {
-					goto l353
+					goto l337
 				}
 				position++
 				if buffer[position] != rune(']') {
-					goto l353
+					goto l337
 				}
 				position++
-				add(ruleTCMarker, position354)
+				add(ruleTCMarker, position338)
 			}
 			return true
-		l353:
-			position, tokenIndex = position353, tokenIndex353
+		l337:
+			position, tokenIndex = position337, tokenIndex337
 			return false
 		},
-		/* 22 EscapedChar <- <('\\' .)> */
+		/* 24 EscapedChar <- <('\\' .)> */
 		func() bool {
-			position355, tokenIndex355 := position, tokenIndex
+			position339, tokenIndex339 := position, tokenIndex
 			{
-				position356 := position
+				position340 := position
 				if buffer[position] != rune('\\') {
-					goto l355
+					goto l339
 				}
 				position++
 				if !matchDot() {
-					goto l355
+					goto l339
 				}
-				add(ruleEscapedChar, position356)
+				add(ruleEscapedChar, position340)
 			}
 			return true
-		l355:
-			position, tokenIndex = position355, tokenIndex355
+		l339:
+			position, tokenIndex = position339, tokenIndex339
 			return false
 		},
-		/* 23 WS <- <(' ' / '\t')+> */
+		/* 25 WS <- <(' ' / '\t')+> */
 		func() bool {
-			position357, tokenIndex357 := position, tokenIndex
+			position341, tokenIndex341 := position, tokenIndex
 			{
-				position358 := position
+				position342 := position
 				{
-					position361, tokenIndex361 := position, tokenIndex
+					position345, tokenIndex345 := position, tokenIndex
 					if buffer[position] != rune(' ') {
-						goto l362
+						goto l346
 					}
 					position++
-					goto l361
-				l362:
-					position, tokenIndex = position361, tokenIndex361
+					goto l345
+				l346:
+					position, tokenIndex = position345, tokenIndex345
 					if buffer[position] != rune('\t') {
-						goto l357
+						goto l341
 					}
 					position++
 				}
-			l361:
-			l359:
+			l345:
+			l343:
 				{
-					position360, tokenIndex360 := position, tokenIndex
+					position344, tokenIndex344 := position, tokenIndex
 					{
-						position363, tokenIndex363 := position, tokenIndex
+						position347, tokenIndex347 := position, tokenIndex
 						if buffer[position] != rune(' ') {
-							goto l364
+							goto l348
 						}
 						position++
-						goto l363
-					l364:
-						position, tokenIndex = position363, tokenIndex363
+						goto l347
+					l348:
+						position, tokenIndex = position347, tokenIndex347
 						if buffer[position] != rune('\t') {
-							goto l360
+							goto l344
 						}
 						position++
 					}
-				l363:
-					goto l359
-				l360:
-					position, tokenIndex = position360, tokenIndex360
+				l347:
+					goto l343
+				l344:
+					position, tokenIndex = position344, tokenIndex344
 				}
-				add(ruleWS, position358)
+				add(ruleWS, position342)
 			}
 			return true
-		l357:
-			position, tokenIndex = position357, tokenIndex357
+		l341:
+			position, tokenIndex = position341, tokenIndex341
 			return false
 		},
-		/* 24 Comment <- <((('/' '/') / '#') (!'\n' .)*)> */
+		/* 26 Comment <- <((('/' '/') / '#') (!'\n' .)*)> */
 		func() bool {
-			position365, tokenIndex365 := position, tokenIndex
+			position349, tokenIndex349 := position, tokenIndex
 			{
-				position366 := position
+				position350 := position
 				{
-					position367, tokenIndex367 := position, tokenIndex
+					position351, tokenIndex351 := position, tokenIndex
 					if buffer[position] != rune('/') {
-						goto l368
+						goto l352
 					}
 					position++
 					if buffer[position] != rune('/') {
-						goto l368
+						goto l352
 					}
 					position++
-					goto l367
-				l368:
-					position, tokenIndex = position367, tokenIndex367
+					goto l351
+				l352:
+					position, tokenIndex = position351, tokenIndex351
 					if buffer[position] != rune('#') {
-						goto l365
+						goto l349
 					}
 					position++
 				}
-			l367:
-			l369:
+			l351:
+			l353:
 				{
-					position370, tokenIndex370 := position, tokenIndex
+					position354, tokenIndex354 := position, tokenIndex
 					{
-						position371, tokenIndex371 := position, tokenIndex
+						position355, tokenIndex355 := position, tokenIndex
 						if buffer[position] != rune('\n') {
-							goto l371
+							goto l355
 						}
 						position++
-						goto l370
-					l371:
-						position, tokenIndex = position371, tokenIndex371
+						goto l354
+					l355:
+						position, tokenIndex = position355, tokenIndex355
 					}
 					if !matchDot() {
-						goto l370
+						goto l354
 					}
-					goto l369
-				l370:
-					position, tokenIndex = position370, tokenIndex370
+					goto l353
+				l354:
+					position, tokenIndex = position354, tokenIndex354
 				}
-				add(ruleComment, position366)
+				add(ruleComment, position350)
 			}
 			return true
-		l365:
-			position, tokenIndex = position365, tokenIndex365
+		l349:
+			position, tokenIndex = position349, tokenIndex349
 			return false
 		},
-		/* 25 Label <- <((LocalSymbol / LocalLabel / SymbolName) ':')> */
+		/* 27 Label <- <((LocalSymbol / LocalLabel / SymbolName) ':')> */
 		func() bool {
-			position372, tokenIndex372 := position, tokenIndex
+			position356, tokenIndex356 := position, tokenIndex
 			{
-				position373 := position
+				position357 := position
 				{
-					position374, tokenIndex374 := position, tokenIndex
+					position358, tokenIndex358 := position, tokenIndex
 					if !_rules[ruleLocalSymbol]() {
-						goto l375
+						goto l359
 					}
-					goto l374
-				l375:
-					position, tokenIndex = position374, tokenIndex374
+					goto l358
+				l359:
+					position, tokenIndex = position358, tokenIndex358
 					if !_rules[ruleLocalLabel]() {
-						goto l376
+						goto l360
 					}
-					goto l374
-				l376:
-					position, tokenIndex = position374, tokenIndex374
+					goto l358
+				l360:
+					position, tokenIndex = position358, tokenIndex358
 					if !_rules[ruleSymbolName]() {
-						goto l372
+						goto l356
 					}
 				}
-			l374:
+			l358:
 				if buffer[position] != rune(':') {
-					goto l372
+					goto l356
 				}
 				position++
-				add(ruleLabel, position373)
+				add(ruleLabel, position357)
 			}
 			return true
-		l372:
-			position, tokenIndex = position372, tokenIndex372
+		l356:
+			position, tokenIndex = position356, tokenIndex356
 			return false
 		},
-		/* 26 SymbolName <- <(([a-z] / [A-Z] / '.' / '_') ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')*)> */
+		/* 28 SymbolName <- <(([a-z] / [A-Z] / '.' / '_') ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')*)> */
 		func() bool {
-			position377, tokenIndex377 := position, tokenIndex
+			position361, tokenIndex361 := position, tokenIndex
 			{
-				position378 := position
+				position362 := position
 				{
-					position379, tokenIndex379 := position, tokenIndex
+					position363, tokenIndex363 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l380
+						goto l364
 					}
 					position++
-					goto l379
-				l380:
-					position, tokenIndex = position379, tokenIndex379
+					goto l363
+				l364:
+					position, tokenIndex = position363, tokenIndex363
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l381
+						goto l365
 					}
 					position++
-					goto l379
-				l381:
-					position, tokenIndex = position379, tokenIndex379
+					goto l363
+				l365:
+					position, tokenIndex = position363, tokenIndex363
 					if buffer[position] != rune('.') {
-						goto l382
+						goto l366
 					}
 					position++
-					goto l379
-				l382:
-					position, tokenIndex = position379, tokenIndex379
+					goto l363
+				l366:
+					position, tokenIndex = position363, tokenIndex363
 					if buffer[position] != rune('_') {
-						goto l377
+						goto l361
 					}
 					position++
 				}
-			l379:
-			l383:
+			l363:
+			l367:
 				{
-					position384, tokenIndex384 := position, tokenIndex
+					position368, tokenIndex368 := position, tokenIndex
 					{
-						position385, tokenIndex385 := position, tokenIndex
+						position369, tokenIndex369 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l386
+							goto l370
 						}
 						position++
-						goto l385
-					l386:
-						position, tokenIndex = position385, tokenIndex385
+						goto l369
+					l370:
+						position, tokenIndex = position369, tokenIndex369
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l387
+							goto l371
 						}
 						position++
-						goto l385
-					l387:
-						position, tokenIndex = position385, tokenIndex385
+						goto l369
+					l371:
+						position, tokenIndex = position369, tokenIndex369
 						if buffer[position] != rune('.') {
-							goto l388
+							goto l372
 						}
 						position++
-						goto l385
-					l388:
-						position, tokenIndex = position385, tokenIndex385
+						goto l369
+					l372:
+						position, tokenIndex = position369, tokenIndex369
 						{
-							position390, tokenIndex390 := position, tokenIndex
+							position374, tokenIndex374 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l391
+								goto l375
 							}
 							position++
-							goto l390
-						l391:
-							position, tokenIndex = position390, tokenIndex390
+							goto l374
+						l375:
+							position, tokenIndex = position374, tokenIndex374
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l389
+								goto l373
 							}
 							position++
 						}
-					l390:
-						goto l385
-					l389:
-						position, tokenIndex = position385, tokenIndex385
+					l374:
+						goto l369
+					l373:
+						position, tokenIndex = position369, tokenIndex369
 						if buffer[position] != rune('$') {
-							goto l392
+							goto l376
 						}
 						position++
-						goto l385
-					l392:
-						position, tokenIndex = position385, tokenIndex385
+						goto l369
+					l376:
+						position, tokenIndex = position369, tokenIndex369
 						if buffer[position] != rune('_') {
-							goto l384
+							goto l368
 						}
 						position++
 					}
-				l385:
-					goto l383
-				l384:
-					position, tokenIndex = position384, tokenIndex384
+				l369:
+					goto l367
+				l368:
+					position, tokenIndex = position368, tokenIndex368
 				}
-				add(ruleSymbolName, position378)
+				add(ruleSymbolName, position362)
 			}
 			return true
-		l377:
-			position, tokenIndex = position377, tokenIndex377
+		l361:
+			position, tokenIndex = position361, tokenIndex361
 			return false
 		},
-		/* 27 LocalSymbol <- <('.' 'L' ([a-z] / [A-Z] / ([a-z] / [A-Z]) / '.' / ([0-9] / [0-9]) / '$' / '_')+)> */
+		/* 29 LocalSymbol <- <('.' 'L' ([a-z] / [A-Z] / ([a-z] / [A-Z]) / '.' / ([0-9] / [0-9]) / '$' / '_')+)> */
 		func() bool {
-			position393, tokenIndex393 := position, tokenIndex
+			position377, tokenIndex377 := position, tokenIndex
 			{
-				position394 := position
+				position378 := position
 				if buffer[position] != rune('.') {
-					goto l393
+					goto l377
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l393
+					goto l377
 				}
 				position++
 				{
-					position397, tokenIndex397 := position, tokenIndex
+					position381, tokenIndex381 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l398
+						goto l382
 					}
 					position++
-					goto l397
-				l398:
-					position, tokenIndex = position397, tokenIndex397
+					goto l381
+				l382:
+					position, tokenIndex = position381, tokenIndex381
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l399
+						goto l383
 					}
 					position++
-					goto l397
-				l399:
-					position, tokenIndex = position397, tokenIndex397
+					goto l381
+				l383:
+					position, tokenIndex = position381, tokenIndex381
 					{
-						position401, tokenIndex401 := position, tokenIndex
+						position385, tokenIndex385 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l402
+							goto l386
 						}
 						position++
-						goto l401
-					l402:
-						position, tokenIndex = position401, tokenIndex401
+						goto l385
+					l386:
+						position, tokenIndex = position385, tokenIndex385
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l400
+							goto l384
 						}
 						position++
 					}
-				l401:
-					goto l397
-				l400:
-					position, tokenIndex = position397, tokenIndex397
+				l385:
+					goto l381
+				l384:
+					position, tokenIndex = position381, tokenIndex381
 					if buffer[position] != rune('.') {
-						goto l403
+						goto l387
 					}
 					position++
-					goto l397
-				l403:
-					position, tokenIndex = position397, tokenIndex397
+					goto l381
+				l387:
+					position, tokenIndex = position381, tokenIndex381
 					{
-						position405, tokenIndex405 := position, tokenIndex
+						position389, tokenIndex389 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l406
+							goto l390
 						}
 						position++
-						goto l405
-					l406:
-						position, tokenIndex = position405, tokenIndex405
+						goto l389
+					l390:
+						position, tokenIndex = position389, tokenIndex389
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l404
+							goto l388
 						}
 						position++
 					}
-				l405:
-					goto l397
-				l404:
-					position, tokenIndex = position397, tokenIndex397
+				l389:
+					goto l381
+				l388:
+					position, tokenIndex = position381, tokenIndex381
 					if buffer[position] != rune('$') {
-						goto l407
+						goto l391
 					}
 					position++
-					goto l397
-				l407:
-					position, tokenIndex = position397, tokenIndex397
+					goto l381
+				l391:
+					position, tokenIndex = position381, tokenIndex381
 					if buffer[position] != rune('_') {
-						goto l393
+						goto l377
 					}
 					position++
 				}
-			l397:
-			l395:
+			l381:
+			l379:
 				{
-					position396, tokenIndex396 := position, tokenIndex
+					position380, tokenIndex380 := position, tokenIndex
 					{
-						position408, tokenIndex408 := position, tokenIndex
+						position392, tokenIndex392 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l409
+							goto l393
 						}
 						position++
-						goto l408
-					l409:
-						position, tokenIndex = position408, tokenIndex408
+						goto l392
+					l393:
+						position, tokenIndex = position392, tokenIndex392
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l410
+							goto l394
 						}
 						position++
-						goto l408
-					l410:
-						position, tokenIndex = position408, tokenIndex408
+						goto l392
+					l394:
+						position, tokenIndex = position392, tokenIndex392
 						{
-							position412, tokenIndex412 := position, tokenIndex
+							position396, tokenIndex396 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l413
+								goto l397
 							}
 							position++
-							goto l412
-						l413:
-							position, tokenIndex = position412, tokenIndex412
+							goto l396
+						l397:
+							position, tokenIndex = position396, tokenIndex396
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l411
+								goto l395
 							}
 							position++
 						}
-					l412:
-						goto l408
-					l411:
-						position, tokenIndex = position408, tokenIndex408
+					l396:
+						goto l392
+					l395:
+						position, tokenIndex = position392, tokenIndex392
 						if buffer[position] != rune('.') {
-							goto l414
+							goto l398
 						}
 						position++
-						goto l408
-					l414:
-						position, tokenIndex = position408, tokenIndex408
+						goto l392
+					l398:
+						position, tokenIndex = position392, tokenIndex392
 						{
-							position416, tokenIndex416 := position, tokenIndex
+							position400, tokenIndex400 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l417
+								goto l401
 							}
 							position++
-							goto l416
-						l417:
-							position, tokenIndex = position416, tokenIndex416
+							goto l400
+						l401:
+							position, tokenIndex = position400, tokenIndex400
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l415
+								goto l399
 							}
 							position++
 						}
-					l416:
-						goto l408
-					l415:
-						position, tokenIndex = position408, tokenIndex408
+					l400:
+						goto l392
+					l399:
+						position, tokenIndex = position392, tokenIndex392
 						if buffer[position] != rune('$') {
-							goto l418
+							goto l402
 						}
 						position++
-						goto l408
-					l418:
-						position, tokenIndex = position408, tokenIndex408
+						goto l392
+					l402:
+						position, tokenIndex = position392, tokenIndex392
 						if buffer[position] != rune('_') {
-							goto l396
+							goto l380
 						}
 						position++
 					}
-				l408:
-					goto l395
-				l396:
-					position, tokenIndex = position396, tokenIndex396
+				l392:
+					goto l379
+				l380:
+					position, tokenIndex = position380, tokenIndex380
 				}
-				add(ruleLocalSymbol, position394)
+				add(ruleLocalSymbol, position378)
 			}
 			return true
-		l393:
-			position, tokenIndex = position393, tokenIndex393
+		l377:
+			position, tokenIndex = position377, tokenIndex377
 			return false
 		},
-		/* 28 LocalLabel <- <([0-9] ([0-9] / '$')*)> */
+		/* 30 LocalLabel <- <([0-9] ([0-9] / '$')*)> */
 		func() bool {
-			position419, tokenIndex419 := position, tokenIndex
+			position403, tokenIndex403 := position, tokenIndex
 			{
-				position420 := position
+				position404 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l419
+					goto l403
 				}
 				position++
-			l421:
+			l405:
 				{
-					position422, tokenIndex422 := position, tokenIndex
+					position406, tokenIndex406 := position, tokenIndex
 					{
-						position423, tokenIndex423 := position, tokenIndex
+						position407, tokenIndex407 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l424
+							goto l408
 						}
 						position++
-						goto l423
-					l424:
-						position, tokenIndex = position423, tokenIndex423
+						goto l407
+					l408:
+						position, tokenIndex = position407, tokenIndex407
 						if buffer[position] != rune('$') {
-							goto l422
+							goto l406
 						}
 						position++
 					}
-				l423:
-					goto l421
-				l422:
-					position, tokenIndex = position422, tokenIndex422
+				l407:
+					goto l405
+				l406:
+					position, tokenIndex = position406, tokenIndex406
 				}
-				add(ruleLocalLabel, position420)
+				add(ruleLocalLabel, position404)
 			}
 			return true
-		l419:
-			position, tokenIndex = position419, tokenIndex419
+		l403:
+			position, tokenIndex = position403, tokenIndex403
 			return false
 		},
-		/* 29 LocalLabelRef <- <([0-9] ([0-9] / '$')* ('b' / 'f'))> */
+		/* 31 LocalLabelRef <- <([0-9] ([0-9] / '$')* ('b' / 'f'))> */
 		func() bool {
-			position425, tokenIndex425 := position, tokenIndex
+			position409, tokenIndex409 := position, tokenIndex
 			{
-				position426 := position
+				position410 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l425
+					goto l409
 				}
 				position++
-			l427:
+			l411:
 				{
-					position428, tokenIndex428 := position, tokenIndex
+					position412, tokenIndex412 := position, tokenIndex
 					{
-						position429, tokenIndex429 := position, tokenIndex
+						position413, tokenIndex413 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l430
+							goto l414
 						}
 						position++
-						goto l429
-					l430:
-						position, tokenIndex = position429, tokenIndex429
+						goto l413
+					l414:
+						position, tokenIndex = position413, tokenIndex413
 						if buffer[position] != rune('$') {
-							goto l428
+							goto l412
 						}
 						position++
 					}
-				l429:
-					goto l427
-				l428:
-					position, tokenIndex = position428, tokenIndex428
+				l413:
+					goto l411
+				l412:
+					position, tokenIndex = position412, tokenIndex412
 				}
 				{
-					position431, tokenIndex431 := position, tokenIndex
+					position415, tokenIndex415 := position, tokenIndex
 					if buffer[position] != rune('b') {
-						goto l432
+						goto l416
 					}
 					position++
-					goto l431
-				l432:
-					position, tokenIndex = position431, tokenIndex431
+					goto l415
+				l416:
+					position, tokenIndex = position415, tokenIndex415
 					if buffer[position] != rune('f') {
-						goto l425
+						goto l409
 					}
 					position++
 				}
-			l431:
-				add(ruleLocalLabelRef, position426)
+			l415:
+				add(ruleLocalLabelRef, position410)
 			}
 			return true
-		l425:
-			position, tokenIndex = position425, tokenIndex425
+		l409:
+			position, tokenIndex = position409, tokenIndex409
 			return false
 		},
-		/* 30 Instruction <- <(InstructionName (WS InstructionArg (WS? ','? WS? InstructionArg)*)?)> */
+		/* 32 Instruction <- <(InstructionName (WS InstructionArg (WS? ','? WS? InstructionArg)*)?)> */
 		func() bool {
-			position433, tokenIndex433 := position, tokenIndex
+			position417, tokenIndex417 := position, tokenIndex
 			{
-				position434 := position
+				position418 := position
 				if !_rules[ruleInstructionName]() {
-					goto l433
+					goto l417
 				}
 				{
-					position435, tokenIndex435 := position, tokenIndex
+					position419, tokenIndex419 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l435
+						goto l419
 					}
 					if !_rules[ruleInstructionArg]() {
-						goto l435
+						goto l419
 					}
-				l437:
+				l421:
 					{
-						position438, tokenIndex438 := position, tokenIndex
+						position422, tokenIndex422 := position, tokenIndex
 						{
-							position439, tokenIndex439 := position, tokenIndex
+							position423, tokenIndex423 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l439
+								goto l423
 							}
-							goto l440
-						l439:
-							position, tokenIndex = position439, tokenIndex439
+							goto l424
+						l423:
+							position, tokenIndex = position423, tokenIndex423
 						}
-					l440:
+					l424:
 						{
-							position441, tokenIndex441 := position, tokenIndex
+							position425, tokenIndex425 := position, tokenIndex
 							if buffer[position] != rune(',') {
-								goto l441
+								goto l425
 							}
 							position++
-							goto l442
-						l441:
-							position, tokenIndex = position441, tokenIndex441
+							goto l426
+						l425:
+							position, tokenIndex = position425, tokenIndex425
 						}
-					l442:
+					l426:
 						{
-							position443, tokenIndex443 := position, tokenIndex
+							position427, tokenIndex427 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l443
+								goto l427
 							}
-							goto l444
-						l443:
-							position, tokenIndex = position443, tokenIndex443
+							goto l428
+						l427:
+							position, tokenIndex = position427, tokenIndex427
 						}
-					l444:
+					l428:
 						if !_rules[ruleInstructionArg]() {
-							goto l438
+							goto l422
 						}
-						goto l437
-					l438:
-						position, tokenIndex = position438, tokenIndex438
+						goto l421
+					l422:
+						position, tokenIndex = position422, tokenIndex422
 					}
-					goto l436
-				l435:
-					position, tokenIndex = position435, tokenIndex435
+					goto l420
+				l419:
+					position, tokenIndex = position419, tokenIndex419
 				}
-			l436:
-				add(ruleInstruction, position434)
+			l420:
+				add(ruleInstruction, position418)
 			}
 			return true
-		l433:
-			position, tokenIndex = position433, tokenIndex433
+		l417:
+			position, tokenIndex = position417, tokenIndex417
 			return false
 		},
-		/* 31 InstructionName <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]))* ('.' / '+' / '-')?)> */
+		/* 33 InstructionName <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]))* ('.' / '+' / '-')?)> */
 		func() bool {
-			position445, tokenIndex445 := position, tokenIndex
+			position429, tokenIndex429 := position, tokenIndex
 			{
-				position446 := position
+				position430 := position
 				{
-					position447, tokenIndex447 := position, tokenIndex
+					position431, tokenIndex431 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l448
+						goto l432
 					}
 					position++
-					goto l447
-				l448:
-					position, tokenIndex = position447, tokenIndex447
+					goto l431
+				l432:
+					position, tokenIndex = position431, tokenIndex431
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l445
+						goto l429
 					}
 					position++
 				}
-			l447:
-			l449:
+			l431:
+			l433:
 				{
-					position450, tokenIndex450 := position, tokenIndex
+					position434, tokenIndex434 := position, tokenIndex
 					{
-						position451, tokenIndex451 := position, tokenIndex
+						position435, tokenIndex435 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l452
+							goto l436
 						}
 						position++
-						goto l451
-					l452:
-						position, tokenIndex = position451, tokenIndex451
+						goto l435
+					l436:
+						position, tokenIndex = position435, tokenIndex435
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l453
+							goto l437
 						}
 						position++
-						goto l451
-					l453:
-						position, tokenIndex = position451, tokenIndex451
+						goto l435
+					l437:
+						position, tokenIndex = position435, tokenIndex435
 						if buffer[position] != rune('.') {
-							goto l454
+							goto l438
 						}
 						position++
-						goto l451
-					l454:
-						position, tokenIndex = position451, tokenIndex451
+						goto l435
+					l438:
+						position, tokenIndex = position435, tokenIndex435
 						{
-							position455, tokenIndex455 := position, tokenIndex
+							position439, tokenIndex439 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l456
+								goto l440
 							}
 							position++
-							goto l455
-						l456:
-							position, tokenIndex = position455, tokenIndex455
+							goto l439
+						l440:
+							position, tokenIndex = position439, tokenIndex439
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l450
+								goto l434
 							}
 							position++
 						}
-					l455:
+					l439:
 					}
-				l451:
-					goto l449
-				l450:
-					position, tokenIndex = position450, tokenIndex450
+				l435:
+					goto l433
+				l434:
+					position, tokenIndex = position434, tokenIndex434
 				}
 				{
-					position457, tokenIndex457 := position, tokenIndex
+					position441, tokenIndex441 := position, tokenIndex
 					{
-						position459, tokenIndex459 := position, tokenIndex
+						position443, tokenIndex443 := position, tokenIndex
 						if buffer[position] != rune('.') {
-							goto l460
+							goto l444
 						}
 						position++
-						goto l459
-					l460:
-						position, tokenIndex = position459, tokenIndex459
+						goto l443
+					l444:
+						position, tokenIndex = position443, tokenIndex443
 						if buffer[position] != rune('+') {
-							goto l461
+							goto l445
 						}
 						position++
-						goto l459
-					l461:
-						position, tokenIndex = position459, tokenIndex459
+						goto l443
+					l445:
+						position, tokenIndex = position443, tokenIndex443
 						if buffer[position] != rune('-') {
-							goto l457
+							goto l441
 						}
 						position++
 					}
-				l459:
-					goto l458
-				l457:
-					position, tokenIndex = position457, tokenIndex457
+				l443:
+					goto l442
+				l441:
+					position, tokenIndex = position441, tokenIndex441
 				}
-			l458:
-				add(ruleInstructionName, position446)
+			l442:
+				add(ruleInstructionName, position430)
 			}
 			return true
-		l445:
-			position, tokenIndex = position445, tokenIndex445
+		l429:
+			position, tokenIndex = position429, tokenIndex429
 			return false
 		},
-		/* 32 InstructionArg <- <(IndirectionIndicator? (ARMConstantTweak / RegisterOrConstant / LocalLabelRef / TOCRefHigh / TOCRefLow / GOTLocation / GOTSymbolOffset / MemoryRef) AVX512Token*)> */
+		/* 34 InstructionArg <- <(IndirectionIndicator? (ARMConstantTweak / RegisterOrConstant / LocalLabelRef / TOCRefHigh / TOCRefLow / GOTLocation / GOTSymbolOffset / MemoryRef) AVX512Token*)> */
 		func() bool {
-			position462, tokenIndex462 := position, tokenIndex
+			position446, tokenIndex446 := position, tokenIndex
 			{
-				position463 := position
+				position447 := position
 				{
-					position464, tokenIndex464 := position, tokenIndex
+					position448, tokenIndex448 := position, tokenIndex
 					if !_rules[ruleIndirectionIndicator]() {
-						goto l464
+						goto l448
 					}
-					goto l465
-				l464:
-					position, tokenIndex = position464, tokenIndex464
+					goto l449
+				l448:
+					position, tokenIndex = position448, tokenIndex448
 				}
-			l465:
+			l449:
 				{
-					position466, tokenIndex466 := position, tokenIndex
+					position450, tokenIndex450 := position, tokenIndex
 					if !_rules[ruleARMConstantTweak]() {
-						goto l467
+						goto l451
 					}
-					goto l466
-				l467:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l451:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleRegisterOrConstant]() {
-						goto l468
+						goto l452
 					}
-					goto l466
-				l468:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l452:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleLocalLabelRef]() {
-						goto l469
+						goto l453
 					}
-					goto l466
-				l469:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l453:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleTOCRefHigh]() {
-						goto l470
+						goto l454
 					}
-					goto l466
-				l470:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l454:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleTOCRefLow]() {
-						goto l471
+						goto l455
 					}
-					goto l466
-				l471:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l455:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleGOTLocation]() {
-						goto l472
+						goto l456
 					}
-					goto l466
-				l472:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l456:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleGOTSymbolOffset]() {
-						goto l473
+						goto l457
 					}
-					goto l466
-				l473:
-					position, tokenIndex = position466, tokenIndex466
+					goto l450
+				l457:
+					position, tokenIndex = position450, tokenIndex450
 					if !_rules[ruleMemoryRef]() {
-						goto l462
+						goto l446
 					}
 				}
-			l466:
-			l474:
+			l450:
+			l458:
 				{
-					position475, tokenIndex475 := position, tokenIndex
+					position459, tokenIndex459 := position, tokenIndex
 					if !_rules[ruleAVX512Token]() {
-						goto l475
+						goto l459
 					}
-					goto l474
-				l475:
-					position, tokenIndex = position475, tokenIndex475
+					goto l458
+				l459:
+					position, tokenIndex = position459, tokenIndex459
 				}
-				add(ruleInstructionArg, position463)
+				add(ruleInstructionArg, position447)
 			}
 			return true
-		l462:
-			position, tokenIndex = position462, tokenIndex462
+		l446:
+			position, tokenIndex = position446, tokenIndex446
 			return false
 		},
-		/* 33 GOTLocation <- <('$' '_' 'G' 'L' 'O' 'B' 'A' 'L' '_' 'O' 'F' 'F' 'S' 'E' 'T' '_' 'T' 'A' 'B' 'L' 'E' '_' '-' LocalSymbol)> */
+		/* 35 GOTLocation <- <('$' '_' 'G' 'L' 'O' 'B' 'A' 'L' '_' 'O' 'F' 'F' 'S' 'E' 'T' '_' 'T' 'A' 'B' 'L' 'E' '_' '-' LocalSymbol)> */
 		func() bool {
-			position476, tokenIndex476 := position, tokenIndex
+			position460, tokenIndex460 := position, tokenIndex
 			{
-				position477 := position
+				position461 := position
 				if buffer[position] != rune('$') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('G') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('B') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('A') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('F') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('F') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('S') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('E') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('A') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('B') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('L') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('E') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('_') {
-					goto l476
+					goto l460
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l476
+					goto l460
 				}
 				position++
 				if !_rules[ruleLocalSymbol]() {
-					goto l476
+					goto l460
 				}
-				add(ruleGOTLocation, position477)
+				add(ruleGOTLocation, position461)
 			}
 			return true
-		l476:
-			position, tokenIndex = position476, tokenIndex476
+		l460:
+			position, tokenIndex = position460, tokenIndex460
 			return false
 		},
-		/* 34 GOTSymbolOffset <- <(('$' SymbolName ('@' 'G' 'O' 'T') ('O' 'F' 'F')?) / (':' ('g' / 'G') ('o' / 'O') ('t' / 'T') ':' SymbolName))> */
+		/* 36 GOTSymbolOffset <- <(('$' SymbolName ('@' 'G' 'O' 'T') ('O' 'F' 'F')?) / (':' ('g' / 'G') ('o' / 'O') ('t' / 'T') ':' SymbolName))> */
 		func() bool {
-			position478, tokenIndex478 := position, tokenIndex
+			position462, tokenIndex462 := position, tokenIndex
 			{
-				position479 := position
+				position463 := position
 				{
-					position480, tokenIndex480 := position, tokenIndex
+					position464, tokenIndex464 := position, tokenIndex
 					if buffer[position] != rune('$') {
-						goto l481
+						goto l465
 					}
 					position++
 					if !_rules[ruleSymbolName]() {
-						goto l481
+						goto l465
 					}
 					if buffer[position] != rune('@') {
-						goto l481
+						goto l465
 					}
 					position++
 					if buffer[position] != rune('G') {
-						goto l481
+						goto l465
 					}
 					position++
 					if buffer[position] != rune('O') {
-						goto l481
+						goto l465
 					}
 					position++
 					if buffer[position] != rune('T') {
-						goto l481
+						goto l465
 					}
 					position++
 					{
-						position482, tokenIndex482 := position, tokenIndex
+						position466, tokenIndex466 := position, tokenIndex
 						if buffer[position] != rune('O') {
-							goto l482
+							goto l466
 						}
 						position++
 						if buffer[position] != rune('F') {
-							goto l482
+							goto l466
 						}
 						position++
 						if buffer[position] != rune('F') {
-							goto l482
+							goto l466
 						}
 						position++
-						goto l483
-					l482:
-						position, tokenIndex = position482, tokenIndex482
+						goto l467
+					l466:
+						position, tokenIndex = position466, tokenIndex466
 					}
-				l483:
-					goto l480
-				l481:
-					position, tokenIndex = position480, tokenIndex480
+				l467:
+					goto l464
+				l465:
+					position, tokenIndex = position464, tokenIndex464
 					if buffer[position] != rune(':') {
-						goto l478
+						goto l462
 					}
 					position++
 					{
-						position484, tokenIndex484 := position, tokenIndex
+						position468, tokenIndex468 := position, tokenIndex
 						if buffer[position] != rune('g') {
-							goto l485
+							goto l469
 						}
 						position++
-						goto l484
-					l485:
-						position, tokenIndex = position484, tokenIndex484
+						goto l468
+					l469:
+						position, tokenIndex = position468, tokenIndex468
 						if buffer[position] != rune('G') {
-							goto l478
+							goto l462
 						}
 						position++
 					}
-				l484:
+				l468:
 					{
-						position486, tokenIndex486 := position, tokenIndex
+						position470, tokenIndex470 := position, tokenIndex
 						if buffer[position] != rune('o') {
-							goto l487
+							goto l471
 						}
 						position++
-						goto l486
-					l487:
-						position, tokenIndex = position486, tokenIndex486
+						goto l470
+					l471:
+						position, tokenIndex = position470, tokenIndex470
 						if buffer[position] != rune('O') {
-							goto l478
+							goto l462
 						}
 						position++
 					}
-				l486:
+				l470:
 					{
-						position488, tokenIndex488 := position, tokenIndex
+						position472, tokenIndex472 := position, tokenIndex
 						if buffer[position] != rune('t') {
-							goto l489
+							goto l473
 						}
 						position++
-						goto l488
-					l489:
-						position, tokenIndex = position488, tokenIndex488
+						goto l472
+					l473:
+						position, tokenIndex = position472, tokenIndex472
 						if buffer[position] != rune('T') {
-							goto l478
+							goto l462
 						}
 						position++
 					}
-				l488:
+				l472:
 					if buffer[position] != rune(':') {
-						goto l478
+						goto l462
 					}
 					position++
 					if !_rules[ruleSymbolName]() {
-						goto l478
+						goto l462
 					}
 				}
-			l480:
-				add(ruleGOTSymbolOffset, position479)
+			l464:
+				add(ruleGOTSymbolOffset, position463)
 			}
 			return true
-		l478:
-			position, tokenIndex = position478, tokenIndex478
+		l462:
+			position, tokenIndex = position462, tokenIndex462
 			return false
 		},
-		/* 35 AVX512Token <- <(WS? '{' '%'? ([0-9] / [a-z])* '}')> */
+		/* 37 AVX512Token <- <(WS? '{' '%'? ([0-9] / [a-z])* '}')> */
 		func() bool {
-			position490, tokenIndex490 := position, tokenIndex
+			position474, tokenIndex474 := position, tokenIndex
 			{
-				position491 := position
+				position475 := position
 				{
-					position492, tokenIndex492 := position, tokenIndex
+					position476, tokenIndex476 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l492
+						goto l476
 					}
-					goto l493
-				l492:
-					position, tokenIndex = position492, tokenIndex492
+					goto l477
+				l476:
+					position, tokenIndex = position476, tokenIndex476
 				}
-			l493:
+			l477:
 				if buffer[position] != rune('{') {
-					goto l490
+					goto l474
 				}
 				position++
 				{
-					position494, tokenIndex494 := position, tokenIndex
+					position478, tokenIndex478 := position, tokenIndex
 					if buffer[position] != rune('%') {
-						goto l494
+						goto l478
 					}
 					position++
-					goto l495
-				l494:
-					position, tokenIndex = position494, tokenIndex494
+					goto l479
+				l478:
+					position, tokenIndex = position478, tokenIndex478
 				}
-			l495:
-			l496:
+			l479:
+			l480:
 				{
-					position497, tokenIndex497 := position, tokenIndex
+					position481, tokenIndex481 := position, tokenIndex
 					{
-						position498, tokenIndex498 := position, tokenIndex
+						position482, tokenIndex482 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l499
+							goto l483
 						}
 						position++
-						goto l498
-					l499:
-						position, tokenIndex = position498, tokenIndex498
+						goto l482
+					l483:
+						position, tokenIndex = position482, tokenIndex482
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l497
+							goto l481
 						}
 						position++
 					}
-				l498:
-					goto l496
-				l497:
-					position, tokenIndex = position497, tokenIndex497
+				l482:
+					goto l480
+				l481:
+					position, tokenIndex = position481, tokenIndex481
 				}
 				if buffer[position] != rune('}') {
-					goto l490
+					goto l474
 				}
 				position++
-				add(ruleAVX512Token, position491)
+				add(ruleAVX512Token, position475)
 			}
 			return true
-		l490:
-			position, tokenIndex = position490, tokenIndex490
+		l474:
+			position, tokenIndex = position474, tokenIndex474
 			return false
 		},
-		/* 36 TOCRefHigh <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('h' / 'H') ('a' / 'A')))> */
+		/* 38 TOCRefHigh <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('h' / 'H') ('a' / 'A')))> */
 		func() bool {
-			position500, tokenIndex500 := position, tokenIndex
+			position484, tokenIndex484 := position, tokenIndex
 			{
-				position501 := position
+				position485 := position
 				if buffer[position] != rune('.') {
-					goto l500
+					goto l484
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l500
+					goto l484
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l500
+					goto l484
 				}
 				position++
 				if buffer[position] != rune('C') {
-					goto l500
+					goto l484
 				}
 				position++
 				if buffer[position] != rune('.') {
-					goto l500
+					goto l484
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l500
+					goto l484
 				}
 				position++
 				{
-					position502, tokenIndex502 := position, tokenIndex
+					position486, tokenIndex486 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l503
+						goto l487
 					}
 					position++
 					if buffer[position] != rune('b') {
-						goto l503
+						goto l487
 					}
 					position++
-					goto l502
-				l503:
-					position, tokenIndex = position502, tokenIndex502
+					goto l486
+				l487:
+					position, tokenIndex = position486, tokenIndex486
 					if buffer[position] != rune('.') {
-						goto l500
+						goto l484
 					}
 					position++
 					if buffer[position] != rune('L') {
-						goto l500
+						goto l484
 					}
 					position++
 					{
-						position506, tokenIndex506 := position, tokenIndex
+						position490, tokenIndex490 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l507
+							goto l491
 						}
 						position++
-						goto l506
-					l507:
-						position, tokenIndex = position506, tokenIndex506
+						goto l490
+					l491:
+						position, tokenIndex = position490, tokenIndex490
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l508
+							goto l492
 						}
 						position++
-						goto l506
-					l508:
-						position, tokenIndex = position506, tokenIndex506
+						goto l490
+					l492:
+						position, tokenIndex = position490, tokenIndex490
 						if buffer[position] != rune('_') {
-							goto l509
+							goto l493
 						}
 						position++
-						goto l506
-					l509:
-						position, tokenIndex = position506, tokenIndex506
+						goto l490
+					l493:
+						position, tokenIndex = position490, tokenIndex490
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l500
+							goto l484
 						}
 						position++
 					}
-				l506:
-				l504:
+				l490:
+				l488:
 					{
-						position505, tokenIndex505 := position, tokenIndex
+						position489, tokenIndex489 := position, tokenIndex
 						{
-							position510, tokenIndex510 := position, tokenIndex
+							position494, tokenIndex494 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l511
+								goto l495
 							}
 							position++
-							goto l510
-						l511:
-							position, tokenIndex = position510, tokenIndex510
+							goto l494
+						l495:
+							position, tokenIndex = position494, tokenIndex494
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l512
+								goto l496
 							}
 							position++
-							goto l510
-						l512:
-							position, tokenIndex = position510, tokenIndex510
+							goto l494
+						l496:
+							position, tokenIndex = position494, tokenIndex494
 							if buffer[position] != rune('_') {
-								goto l513
+								goto l497
 							}
 							position++
-							goto l510
-						l513:
-							position, tokenIndex = position510, tokenIndex510
+							goto l494
+						l497:
+							position, tokenIndex = position494, tokenIndex494
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l505
+								goto l489
 							}
 							position++
 						}
-					l510:
-						goto l504
-					l505:
-						position, tokenIndex = position505, tokenIndex505
+					l494:
+						goto l488
+					l489:
+						position, tokenIndex = position489, tokenIndex489
 					}
 				}
-			l502:
+			l486:
 				if buffer[position] != rune('@') {
-					goto l500
+					goto l484
 				}
 				position++
 				{
-					position514, tokenIndex514 := position, tokenIndex
+					position498, tokenIndex498 := position, tokenIndex
 					if buffer[position] != rune('h') {
-						goto l515
+						goto l499
 					}
 					position++
-					goto l514
-				l515:
-					position, tokenIndex = position514, tokenIndex514
+					goto l498
+				l499:
+					position, tokenIndex = position498, tokenIndex498
 					if buffer[position] != rune('H') {
-						goto l500
+						goto l484
 					}
 					position++
 				}
-			l514:
+			l498:
 				{
-					position516, tokenIndex516 := position, tokenIndex
+					position500, tokenIndex500 := position, tokenIndex
 					if buffer[position] != rune('a') {
-						goto l517
+						goto l501
 					}
 					position++
-					goto l516
-				l517:
-					position, tokenIndex = position516, tokenIndex516
+					goto l500
+				l501:
+					position, tokenIndex = position500, tokenIndex500
 					if buffer[position] != rune('A') {
-						goto l500
+						goto l484
 					}
 					position++
 				}
-			l516:
-				add(ruleTOCRefHigh, position501)
+			l500:
+				add(ruleTOCRefHigh, position485)
 			}
 			return true
-		l500:
-			position, tokenIndex = position500, tokenIndex500
+		l484:
+			position, tokenIndex = position484, tokenIndex484
 			return false
 		},
-		/* 37 TOCRefLow <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('l' / 'L')))> */
+		/* 39 TOCRefLow <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('l' / 'L')))> */
 		func() bool {
-			position518, tokenIndex518 := position, tokenIndex
+			position502, tokenIndex502 := position, tokenIndex
 			{
-				position519 := position
+				position503 := position
 				if buffer[position] != rune('.') {
-					goto l518
+					goto l502
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l518
+					goto l502
 				}
 				position++
 				if buffer[position] != rune('O') {
-					goto l518
+					goto l502
 				}
 				position++
 				if buffer[position] != rune('C') {
-					goto l518
+					goto l502
 				}
 				position++
 				if buffer[position] != rune('.') {
-					goto l518
+					goto l502
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l518
+					goto l502
 				}
 				position++
 				{
-					position520, tokenIndex520 := position, tokenIndex
+					position504, tokenIndex504 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l521
+						goto l505
 					}
 					position++
 					if buffer[position] != rune('b') {
-						goto l521
+						goto l505
 					}
 					position++
-					goto l520
-				l521:
-					position, tokenIndex = position520, tokenIndex520
+					goto l504
+				l505:
+					position, tokenIndex = position504, tokenIndex504
 					if buffer[position] != rune('.') {
-						goto l518
+						goto l502
 					}
 					position++
 					if buffer[position] != rune('L') {
-						goto l518
+						goto l502
 					}
 					position++
 					{
-						position524, tokenIndex524 := position, tokenIndex
+						position508, tokenIndex508 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l525
+							goto l509
 						}
 						position++
-						goto l524
-					l525:
-						position, tokenIndex = position524, tokenIndex524
+						goto l508
+					l509:
+						position, tokenIndex = position508, tokenIndex508
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l526
+							goto l510
 						}
 						position++
-						goto l524
-					l526:
-						position, tokenIndex = position524, tokenIndex524
+						goto l508
+					l510:
+						position, tokenIndex = position508, tokenIndex508
 						if buffer[position] != rune('_') {
-							goto l527
+							goto l511
 						}
 						position++
-						goto l524
-					l527:
-						position, tokenIndex = position524, tokenIndex524
+						goto l508
+					l511:
+						position, tokenIndex = position508, tokenIndex508
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l518
+							goto l502
 						}
 						position++
 					}
-				l524:
-				l522:
+				l508:
+				l506:
 					{
-						position523, tokenIndex523 := position, tokenIndex
+						position507, tokenIndex507 := position, tokenIndex
 						{
-							position528, tokenIndex528 := position, tokenIndex
+							position512, tokenIndex512 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l529
+								goto l513
 							}
 							position++
-							goto l528
-						l529:
-							position, tokenIndex = position528, tokenIndex528
+							goto l512
+						l513:
+							position, tokenIndex = position512, tokenIndex512
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l530
+								goto l514
 							}
 							position++
-							goto l528
-						l530:
-							position, tokenIndex = position528, tokenIndex528
+							goto l512
+						l514:
+							position, tokenIndex = position512, tokenIndex512
 							if buffer[position] != rune('_') {
-								goto l531
+								goto l515
 							}
 							position++
-							goto l528
-						l531:
-							position, tokenIndex = position528, tokenIndex528
+							goto l512
+						l515:
+							position, tokenIndex = position512, tokenIndex512
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l523
+								goto l507
 							}
 							position++
 						}
-					l528:
-						goto l522
-					l523:
-						position, tokenIndex = position523, tokenIndex523
+					l512:
+						goto l506
+					l507:
+						position, tokenIndex = position507, tokenIndex507
 					}
 				}
-			l520:
+			l504:
 				if buffer[position] != rune('@') {
-					goto l518
+					goto l502
 				}
 				position++
 				{
-					position532, tokenIndex532 := position, tokenIndex
+					position516, tokenIndex516 := position, tokenIndex
 					if buffer[position] != rune('l') {
-						goto l533
+						goto l517
 					}
 					position++
-					goto l532
-				l533:
-					position, tokenIndex = position532, tokenIndex532
+					goto l516
+				l517:
+					position, tokenIndex = position516, tokenIndex516
 					if buffer[position] != rune('L') {
-						goto l518
+						goto l502
 					}
 					position++
 				}
-			l532:
-				add(ruleTOCRefLow, position519)
+			l516:
+				add(ruleTOCRefLow, position503)
 			}
 			return true
-		l518:
-			position, tokenIndex = position518, tokenIndex518
+		l502:
+			position, tokenIndex = position502, tokenIndex502
 			return false
 		},
-		/* 38 IndirectionIndicator <- <'*'> */
+		/* 40 IndirectionIndicator <- <'*'> */
 		func() bool {
-			position534, tokenIndex534 := position, tokenIndex
+			position518, tokenIndex518 := position, tokenIndex
 			{
-				position535 := position
+				position519 := position
 				if buffer[position] != rune('*') {
-					goto l534
+					goto l518
 				}
 				position++
-				add(ruleIndirectionIndicator, position535)
+				add(ruleIndirectionIndicator, position519)
 			}
 			return true
-		l534:
-			position, tokenIndex = position534, tokenIndex534
+		l518:
+			position, tokenIndex = position518, tokenIndex518
 			return false
 		},
-		/* 39 RegisterOrConstant <- <((('%' ([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))*) / ('$' [0-9]+ WS? '*' WS? '(' [0-9]+ WS? '-' WS? [0-9]+ ')') / ('$'? ((Offset Offset) / Offset)) / ('#' Offset ('*' [0-9]+ ('-' [0-9] [0-9]*)?)?) / ('#' '~'? '(' [0-9] WS? ('<' '<') WS? [0-9] [0-9]? ')') / (('#' / '$') '~'? ('0' 'x')? ([0-9] / [0-9] / ([a-f] / [A-F]))+) / ('$' '(' '-' [0-9]+ ')') / ARMRegister) !('f' / 'b' / ':' / '(' / '+' / '-'))> */
+		/* 41 RegisterOrConstant <- <((('%' ([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))*) / ('$' [0-9]+ WS? '*' WS? '(' [0-9]+ WS? '-' WS? [0-9]+ ')') / ('$'? ((Offset Offset) / Offset)) / ('#' Offset ('*' [0-9]+ ('-' [0-9] [0-9]*)?)?) / ('#' '~'? '(' [0-9] WS? ('<' '<') WS? [0-9] [0-9]? ')') / (('#' / '$') '~'? ('0' 'x')? ([0-9] / [0-9] / ([a-f] / [A-F]))+) / ('$' '(' '-' [0-9]+ ')') / ARMRegister) !('f' / 'b' / ':' / '(' / '+' / '-'))> */
 		func() bool {
-			position536, tokenIndex536 := position, tokenIndex
+			position520, tokenIndex520 := position, tokenIndex
 			{
-				position537 := position
+				position521 := position
 				{
-					position538, tokenIndex538 := position, tokenIndex
+					position522, tokenIndex522 := position, tokenIndex
 					if buffer[position] != rune('%') {
-						goto l539
+						goto l523
 					}
 					position++
 					{
-						position540, tokenIndex540 := position, tokenIndex
+						position524, tokenIndex524 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l541
+							goto l525
 						}
 						position++
-						goto l540
-					l541:
-						position, tokenIndex = position540, tokenIndex540
+						goto l524
+					l525:
+						position, tokenIndex = position524, tokenIndex524
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l539
+							goto l523
 						}
 						position++
 					}
-				l540:
-				l542:
+				l524:
+				l526:
 					{
-						position543, tokenIndex543 := position, tokenIndex
+						position527, tokenIndex527 := position, tokenIndex
 						{
-							position544, tokenIndex544 := position, tokenIndex
+							position528, tokenIndex528 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l545
+								goto l529
 							}
 							position++
-							goto l544
-						l545:
-							position, tokenIndex = position544, tokenIndex544
+							goto l528
+						l529:
+							position, tokenIndex = position528, tokenIndex528
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l546
+								goto l530
 							}
 							position++
-							goto l544
-						l546:
-							position, tokenIndex = position544, tokenIndex544
+							goto l528
+						l530:
+							position, tokenIndex = position528, tokenIndex528
 							{
-								position547, tokenIndex547 := position, tokenIndex
+								position531, tokenIndex531 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l548
+									goto l532
 								}
 								position++
-								goto l547
-							l548:
-								position, tokenIndex = position547, tokenIndex547
+								goto l531
+							l532:
+								position, tokenIndex = position531, tokenIndex531
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l543
+									goto l527
 								}
 								position++
 							}
-						l547:
+						l531:
 						}
-					l544:
-						goto l542
-					l543:
-						position, tokenIndex = position543, tokenIndex543
+					l528:
+						goto l526
+					l527:
+						position, tokenIndex = position527, tokenIndex527
 					}
-					goto l538
-				l539:
-					position, tokenIndex = position538, tokenIndex538
+					goto l522
+				l523:
+					position, tokenIndex = position522, tokenIndex522
 					if buffer[position] != rune('$') {
-						goto l549
+						goto l533
 					}
 					position++
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l549
+						goto l533
 					}
 					position++
-				l550:
+				l534:
 					{
-						position551, tokenIndex551 := position, tokenIndex
+						position535, tokenIndex535 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l551
+							goto l535
 						}
 						position++
-						goto l550
-					l551:
-						position, tokenIndex = position551, tokenIndex551
+						goto l534
+					l535:
+						position, tokenIndex = position535, tokenIndex535
 					}
 					{
-						position552, tokenIndex552 := position, tokenIndex
+						position536, tokenIndex536 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l552
+							goto l536
 						}
-						goto l553
-					l552:
-						position, tokenIndex = position552, tokenIndex552
+						goto l537
+					l536:
+						position, tokenIndex = position536, tokenIndex536
 					}
-				l553:
+				l537:
 					if buffer[position] != rune('*') {
-						goto l549
+						goto l533
 					}
 					position++
 					{
-						position554, tokenIndex554 := position, tokenIndex
+						position538, tokenIndex538 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l554
+							goto l538
 						}
-						goto l555
-					l554:
-						position, tokenIndex = position554, tokenIndex554
+						goto l539
+					l538:
+						position, tokenIndex = position538, tokenIndex538
 					}
-				l555:
+				l539:
 					if buffer[position] != rune('(') {
-						goto l549
+						goto l533
 					}
 					position++
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l549
+						goto l533
 					}
 					position++
-				l556:
+				l540:
 					{
-						position557, tokenIndex557 := position, tokenIndex
+						position541, tokenIndex541 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l557
+							goto l541
 						}
 						position++
-						goto l556
-					l557:
-						position, tokenIndex = position557, tokenIndex557
+						goto l540
+					l541:
+						position, tokenIndex = position541, tokenIndex541
 					}
 					{
-						position558, tokenIndex558 := position, tokenIndex
+						position542, tokenIndex542 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l558
+							goto l542
 						}
-						goto l559
-					l558:
-						position, tokenIndex = position558, tokenIndex558
+						goto l543
+					l542:
+						position, tokenIndex = position542, tokenIndex542
 					}
-				l559:
+				l543:
 					if buffer[position] != rune('-') {
-						goto l549
+						goto l533
 					}
 					position++
 					{
-						position560, tokenIndex560 := position, tokenIndex
+						position544, tokenIndex544 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l560
+							goto l544
 						}
-						goto l561
-					l560:
-						position, tokenIndex = position560, tokenIndex560
+						goto l545
+					l544:
+						position, tokenIndex = position544, tokenIndex544
 					}
-				l561:
+				l545:
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l549
+						goto l533
 					}
 					position++
-				l562:
+				l546:
 					{
-						position563, tokenIndex563 := position, tokenIndex
+						position547, tokenIndex547 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l563
+							goto l547
 						}
 						position++
-						goto l562
-					l563:
-						position, tokenIndex = position563, tokenIndex563
+						goto l546
+					l547:
+						position, tokenIndex = position547, tokenIndex547
 					}
 					if buffer[position] != rune(')') {
-						goto l549
+						goto l533
 					}
 					position++
-					goto l538
-				l549:
-					position, tokenIndex = position538, tokenIndex538
+					goto l522
+				l533:
+					position, tokenIndex = position522, tokenIndex522
 					{
-						position565, tokenIndex565 := position, tokenIndex
+						position549, tokenIndex549 := position, tokenIndex
 						if buffer[position] != rune('$') {
-							goto l565
+							goto l549
 						}
 						position++
-						goto l566
-					l565:
-						position, tokenIndex = position565, tokenIndex565
+						goto l550
+					l549:
+						position, tokenIndex = position549, tokenIndex549
 					}
-				l566:
+				l550:
 					{
-						position567, tokenIndex567 := position, tokenIndex
+						position551, tokenIndex551 := position, tokenIndex
 						if !_rules[ruleOffset]() {
-							goto l568
+							goto l552
 						}
 						if !_rules[ruleOffset]() {
-							goto l568
+							goto l552
 						}
-						goto l567
-					l568:
-						position, tokenIndex = position567, tokenIndex567
+						goto l551
+					l552:
+						position, tokenIndex = position551, tokenIndex551
 						if !_rules[ruleOffset]() {
-							goto l564
+							goto l548
 						}
 					}
-				l567:
-					goto l538
-				l564:
-					position, tokenIndex = position538, tokenIndex538
+				l551:
+					goto l522
+				l548:
+					position, tokenIndex = position522, tokenIndex522
 					if buffer[position] != rune('#') {
-						goto l569
+						goto l553
 					}
 					position++
 					if !_rules[ruleOffset]() {
-						goto l569
+						goto l553
 					}
 					{
-						position570, tokenIndex570 := position, tokenIndex
+						position554, tokenIndex554 := position, tokenIndex
 						if buffer[position] != rune('*') {
-							goto l570
+							goto l554
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l570
+							goto l554
 						}
 						position++
-					l572:
+					l556:
 						{
-							position573, tokenIndex573 := position, tokenIndex
+							position557, tokenIndex557 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l573
+								goto l557
 							}
 							position++
-							goto l572
-						l573:
-							position, tokenIndex = position573, tokenIndex573
+							goto l556
+						l557:
+							position, tokenIndex = position557, tokenIndex557
 						}
 						{
-							position574, tokenIndex574 := position, tokenIndex
+							position558, tokenIndex558 := position, tokenIndex
 							if buffer[position] != rune('-') {
-								goto l574
+								goto l558
 							}
 							position++
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l574
+								goto l558
 							}
 							position++
-						l576:
+						l560:
 							{
-								position577, tokenIndex577 := position, tokenIndex
+								position561, tokenIndex561 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l577
+									goto l561
 								}
 								position++
-								goto l576
-							l577:
-								position, tokenIndex = position577, tokenIndex577
+								goto l560
+							l561:
+								position, tokenIndex = position561, tokenIndex561
 							}
-							goto l575
-						l574:
-							position, tokenIndex = position574, tokenIndex574
+							goto l559
+						l558:
+							position, tokenIndex = position558, tokenIndex558
 						}
-					l575:
-						goto l571
-					l570:
-						position, tokenIndex = position570, tokenIndex570
+					l559:
+						goto l555
+					l554:
+						position, tokenIndex = position554, tokenIndex554
 					}
-				l571:
-					goto l538
-				l569:
-					position, tokenIndex = position538, tokenIndex538
+				l555:
+					goto l522
+				l553:
+					position, tokenIndex = position522, tokenIndex522
 					if buffer[position] != rune('#') {
-						goto l578
+						goto l562
 					}
 					position++
 					{
-						position579, tokenIndex579 := position, tokenIndex
+						position563, tokenIndex563 := position, tokenIndex
 						if buffer[position] != rune('~') {
-							goto l579
+							goto l563
 						}
 						position++
-						goto l580
-					l579:
-						position, tokenIndex = position579, tokenIndex579
+						goto l564
+					l563:
+						position, tokenIndex = position563, tokenIndex563
 					}
-				l580:
+				l564:
 					if buffer[position] != rune('(') {
-						goto l578
+						goto l562
 					}
 					position++
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l578
+						goto l562
 					}
 					position++
 					{
-						position581, tokenIndex581 := position, tokenIndex
+						position565, tokenIndex565 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l581
+							goto l565
 						}
-						goto l582
-					l581:
-						position, tokenIndex = position581, tokenIndex581
+						goto l566
+					l565:
+						position, tokenIndex = position565, tokenIndex565
 					}
-				l582:
+				l566:
 					if buffer[position] != rune('<') {
-						goto l578
+						goto l562
 					}
 					position++
 					if buffer[position] != rune('<') {
-						goto l578
+						goto l562
 					}
 					position++
 					{
-						position583, tokenIndex583 := position, tokenIndex
+						position567, tokenIndex567 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l583
+							goto l567
 						}
-						goto l584
-					l583:
-						position, tokenIndex = position583, tokenIndex583
+						goto l568
+					l567:
+						position, tokenIndex = position567, tokenIndex567
 					}
-				l584:
+				l568:
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l578
+						goto l562
 					}
 					position++
 					{
-						position585, tokenIndex585 := position, tokenIndex
+						position569, tokenIndex569 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l585
+							goto l569
 						}
 						position++
-						goto l586
-					l585:
-						position, tokenIndex = position585, tokenIndex585
+						goto l570
+					l569:
+						position, tokenIndex = position569, tokenIndex569
 					}
-				l586:
+				l570:
 					if buffer[position] != rune(')') {
-						goto l578
+						goto l562
 					}
 					position++
-					goto l538
-				l578:
-					position, tokenIndex = position538, tokenIndex538
+					goto l522
+				l562:
+					position, tokenIndex = position522, tokenIndex522
 					{
-						position588, tokenIndex588 := position, tokenIndex
+						position572, tokenIndex572 := position, tokenIndex
 						if buffer[position] != rune('#') {
-							goto l589
+							goto l573
 						}
 						position++
-						goto l588
-					l589:
-						position, tokenIndex = position588, tokenIndex588
+						goto l572
+					l573:
+						position, tokenIndex = position572, tokenIndex572
 						if buffer[position] != rune('$') {
-							goto l587
+							goto l571
 						}
 						position++
 					}
-				l588:
+				l572:
 					{
-						position590, tokenIndex590 := position, tokenIndex
+						position574, tokenIndex574 := position, tokenIndex
 						if buffer[position] != rune('~') {
-							goto l590
+							goto l574
 						}
 						position++
-						goto l591
-					l590:
-						position, tokenIndex = position590, tokenIndex590
+						goto l575
+					l574:
+						position, tokenIndex = position574, tokenIndex574
 					}
-				l591:
+				l575:
 					{
-						position592, tokenIndex592 := position, tokenIndex
+						position576, tokenIndex576 := position, tokenIndex
 						if buffer[position] != rune('0') {
-							goto l592
+							goto l576
 						}
 						position++
 						if buffer[position] != rune('x') {
-							goto l592
+							goto l576
 						}
 						position++
-						goto l593
-					l592:
-						position, tokenIndex = position592, tokenIndex592
+						goto l577
+					l576:
+						position, tokenIndex = position576, tokenIndex576
 					}
-				l593:
+				l577:
 					{
-						position596, tokenIndex596 := position, tokenIndex
+						position580, tokenIndex580 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l597
+							goto l581
 						}
 						position++
-						goto l596
-					l597:
-						position, tokenIndex = position596, tokenIndex596
+						goto l580
+					l581:
+						position, tokenIndex = position580, tokenIndex580
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l598
+							goto l582
 						}
 						position++
-						goto l596
-					l598:
-						position, tokenIndex = position596, tokenIndex596
+						goto l580
+					l582:
+						position, tokenIndex = position580, tokenIndex580
 						{
-							position599, tokenIndex599 := position, tokenIndex
+							position583, tokenIndex583 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('f') {
-								goto l600
+								goto l584
 							}
 							position++
-							goto l599
-						l600:
-							position, tokenIndex = position599, tokenIndex599
+							goto l583
+						l584:
+							position, tokenIndex = position583, tokenIndex583
 							if c := buffer[position]; c < rune('A') || c > rune('F') {
-								goto l587
+								goto l571
 							}
 							position++
 						}
-					l599:
+					l583:
 					}
-				l596:
-				l594:
+				l580:
+				l578:
 					{
-						position595, tokenIndex595 := position, tokenIndex
+						position579, tokenIndex579 := position, tokenIndex
 						{
-							position601, tokenIndex601 := position, tokenIndex
+							position585, tokenIndex585 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l602
+								goto l586
 							}
 							position++
-							goto l601
-						l602:
-							position, tokenIndex = position601, tokenIndex601
+							goto l585
+						l586:
+							position, tokenIndex = position585, tokenIndex585
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l603
+								goto l587
 							}
 							position++
-							goto l601
-						l603:
-							position, tokenIndex = position601, tokenIndex601
+							goto l585
+						l587:
+							position, tokenIndex = position585, tokenIndex585
 							{
-								position604, tokenIndex604 := position, tokenIndex
+								position588, tokenIndex588 := position, tokenIndex
 								if c := buffer[position]; c < rune('a') || c > rune('f') {
-									goto l605
+									goto l589
 								}
 								position++
-								goto l604
-							l605:
-								position, tokenIndex = position604, tokenIndex604
+								goto l588
+							l589:
+								position, tokenIndex = position588, tokenIndex588
 								if c := buffer[position]; c < rune('A') || c > rune('F') {
-									goto l595
+									goto l579
 								}
 								position++
 							}
-						l604:
+						l588:
 						}
-					l601:
-						goto l594
-					l595:
-						position, tokenIndex = position595, tokenIndex595
+					l585:
+						goto l578
+					l579:
+						position, tokenIndex = position579, tokenIndex579
 					}
-					goto l538
-				l587:
-					position, tokenIndex = position538, tokenIndex538
+					goto l522
+				l571:
+					position, tokenIndex = position522, tokenIndex522
 					if buffer[position] != rune('$') {
-						goto l606
+						goto l590
 					}
 					position++
 					if buffer[position] != rune('(') {
-						goto l606
+						goto l590
 					}
 					position++
 					if buffer[position] != rune('-') {
-						goto l606
+						goto l590
 					}
 					position++
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l606
+						goto l590
 					}
 					position++
-				l607:
+				l591:
 					{
-						position608, tokenIndex608 := position, tokenIndex
+						position592, tokenIndex592 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l608
+							goto l592
 						}
 						position++
-						goto l607
-					l608:
-						position, tokenIndex = position608, tokenIndex608
+						goto l591
+					l592:
+						position, tokenIndex = position592, tokenIndex592
 					}
 					if buffer[position] != rune(')') {
-						goto l606
+						goto l590
 					}
 					position++
-					goto l538
-				l606:
-					position, tokenIndex = position538, tokenIndex538
+					goto l522
+				l590:
+					position, tokenIndex = position522, tokenIndex522
 					if !_rules[ruleARMRegister]() {
-						goto l536
+						goto l520
 					}
 				}
-			l538:
+			l522:
 				{
-					position609, tokenIndex609 := position, tokenIndex
+					position593, tokenIndex593 := position, tokenIndex
 					{
-						position610, tokenIndex610 := position, tokenIndex
+						position594, tokenIndex594 := position, tokenIndex
 						if buffer[position] != rune('f') {
-							goto l611
+							goto l595
 						}
 						position++
-						goto l610
-					l611:
-						position, tokenIndex = position610, tokenIndex610
+						goto l594
+					l595:
+						position, tokenIndex = position594, tokenIndex594
 						if buffer[position] != rune('b') {
-							goto l612
+							goto l596
 						}
 						position++
-						goto l610
-					l612:
-						position, tokenIndex = position610, tokenIndex610
+						goto l594
+					l596:
+						position, tokenIndex = position594, tokenIndex594
 						if buffer[position] != rune(':') {
-							goto l613
+							goto l597
 						}
 						position++
-						goto l610
-					l613:
-						position, tokenIndex = position610, tokenIndex610
+						goto l594
+					l597:
+						position, tokenIndex = position594, tokenIndex594
 						if buffer[position] != rune('(') {
-							goto l614
+							goto l598
 						}
 						position++
-						goto l610
-					l614:
-						position, tokenIndex = position610, tokenIndex610
+						goto l594
+					l598:
+						position, tokenIndex = position594, tokenIndex594
 						if buffer[position] != rune('+') {
-							goto l615
+							goto l599
 						}
 						position++
-						goto l610
-					l615:
-						position, tokenIndex = position610, tokenIndex610
+						goto l594
+					l599:
+						position, tokenIndex = position594, tokenIndex594
 						if buffer[position] != rune('-') {
-							goto l609
+							goto l593
 						}
 						position++
 					}
-				l610:
-					goto l536
-				l609:
-					position, tokenIndex = position609, tokenIndex609
+				l594:
+					goto l520
+				l593:
+					position, tokenIndex = position593, tokenIndex593
 				}
-				add(ruleRegisterOrConstant, position537)
+				add(ruleRegisterOrConstant, position521)
 			}
 			return true
-		l536:
-			position, tokenIndex = position536, tokenIndex536
+		l520:
+			position, tokenIndex = position520, tokenIndex520
 			return false
 		},
-		/* 40 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)?)> */
+		/* 42 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)?)> */
 		func() bool {
-			position616, tokenIndex616 := position, tokenIndex
+			position600, tokenIndex600 := position, tokenIndex
 			{
-				position617 := position
+				position601 := position
 				{
-					position618, tokenIndex618 := position, tokenIndex
+					position602, tokenIndex602 := position, tokenIndex
 					{
-						position620, tokenIndex620 := position, tokenIndex
+						position604, tokenIndex604 := position, tokenIndex
 						if buffer[position] != rune('u') {
-							goto l621
+							goto l605
 						}
 						position++
-						goto l620
-					l621:
-						position, tokenIndex = position620, tokenIndex620
+						goto l604
+					l605:
+						position, tokenIndex = position604, tokenIndex604
 						if buffer[position] != rune('s') {
-							goto l619
+							goto l603
 						}
 						position++
 					}
-				l620:
+				l604:
 					{
-						position622, tokenIndex622 := position, tokenIndex
+						position606, tokenIndex606 := position, tokenIndex
 						if buffer[position] != rune('x') {
-							goto l623
+							goto l607
 						}
 						position++
-						goto l622
-					l623:
-						position, tokenIndex = position622, tokenIndex622
+						goto l606
+					l607:
+						position, tokenIndex = position606, tokenIndex606
 						if buffer[position] != rune('X') {
-							goto l619
+							goto l603
 						}
 						position++
 					}
-				l622:
+				l606:
 					{
-						position624, tokenIndex624 := position, tokenIndex
+						position608, tokenIndex608 := position, tokenIndex
 						if buffer[position] != rune('t') {
-							goto l625
+							goto l609
 						}
 						position++
-						goto l624
-					l625:
-						position, tokenIndex = position624, tokenIndex624
+						goto l608
+					l609:
+						position, tokenIndex = position608, tokenIndex608
 						if buffer[position] != rune('T') {
-							goto l619
+							goto l603
 						}
 						position++
 					}
-				l624:
+				l608:
 					{
-						position626, tokenIndex626 := position, tokenIndex
+						position610, tokenIndex610 := position, tokenIndex
 						if buffer[position] != rune('x') {
-							goto l627
+							goto l611
 						}
 						position++
-						goto l626
-					l627:
-						position, tokenIndex = position626, tokenIndex626
+						goto l610
+					l611:
+						position, tokenIndex = position610, tokenIndex610
 						if buffer[position] != rune('w') {
-							goto l628
+							goto l612
 						}
 						position++
-						goto l626
-					l628:
-						position, tokenIndex = position626, tokenIndex626
+						goto l610
+					l612:
+						position, tokenIndex = position610, tokenIndex610
 						if buffer[position] != rune('h') {
-							goto l629
+							goto l613
 						}
 						position++
-						goto l626
-					l629:
-						position, tokenIndex = position626, tokenIndex626
+						goto l610
+					l613:
+						position, tokenIndex = position610, tokenIndex610
 						if buffer[position] != rune('b') {
-							goto l619
+							goto l603
 						}
 						position++
 					}
-				l626:
-					goto l618
-				l619:
-					position, tokenIndex = position618, tokenIndex618
+				l610:
+					goto l602
+				l603:
+					position, tokenIndex = position602, tokenIndex602
 					{
-						position631, tokenIndex631 := position, tokenIndex
+						position615, tokenIndex615 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l632
+							goto l616
 						}
 						position++
-						goto l631
-					l632:
-						position, tokenIndex = position631, tokenIndex631
+						goto l615
+					l616:
+						position, tokenIndex = position615, tokenIndex615
 						if buffer[position] != rune('L') {
-							goto l630
+							goto l614
 						}
 						position++
 					}
-				l631:
+				l615:
 					{
-						position633, tokenIndex633 := position, tokenIndex
+						position617, tokenIndex617 := position, tokenIndex
 						if buffer[position] != rune('s') {
-							goto l634
+							goto l618
 						}
 						position++
-						goto l633
-					l634:
-						position, tokenIndex = position633, tokenIndex633
+						goto l617
+					l618:
+						position, tokenIndex = position617, tokenIndex617
 						if buffer[position] != rune('S') {
-							goto l630
+							goto l614
 						}
 						position++
 					}
-				l633:
+				l617:
 					{
-						position635, tokenIndex635 := position, tokenIndex
+						position619, tokenIndex619 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l636
+							goto l620
 						}
 						position++
-						goto l635
-					l636:
-						position, tokenIndex = position635, tokenIndex635
+						goto l619
+					l620:
+						position, tokenIndex = position619, tokenIndex619
 						if buffer[position] != rune('L') {
-							goto l630
+							goto l614
 						}
 						position++
 					}
-				l635:
-					goto l618
-				l630:
-					position, tokenIndex = position618, tokenIndex618
+				l619:
+					goto l602
+				l614:
+					position, tokenIndex = position602, tokenIndex602
 					{
-						position638, tokenIndex638 := position, tokenIndex
+						position622, tokenIndex622 := position, tokenIndex
 						if buffer[position] != rune('l') {
-							goto l639
+							goto l623
 						}
 						position++
-						goto l638
-					l639:
-						position, tokenIndex = position638, tokenIndex638
+						goto l622
+					l623:
+						position, tokenIndex = position622, tokenIndex622
 						if buffer[position] != rune('L') {
-							goto l637
+							goto l621
 						}
 						position++
 					}
-				l638:
+				l622:
 					{
-						position640, tokenIndex640 := position, tokenIndex
+						position624, tokenIndex624 := position, tokenIndex
 						if buffer[position] != rune('s') {
-							goto l641
+							goto l625
 						}
 						position++
-						goto l640
-					l641:
-						position, tokenIndex = position640, tokenIndex640
+						goto l624
+					l625:
+						position, tokenIndex = position624, tokenIndex624
 						if buffer[position] != rune('S') {
-							goto l637
+							goto l621
 						}
 						position++
 					}
-				l640:
+				l624:
 					{
-						position642, tokenIndex642 := position, tokenIndex
+						position626, tokenIndex626 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l643
+							goto l627
 						}
 						position++
-						goto l642
-					l643:
-						position, tokenIndex = position642, tokenIndex642
+						goto l626
+					l627:
+						position, tokenIndex = position626, tokenIndex626
 						if buffer[position] != rune('R') {
-							goto l637
+							goto l621
 						}
 						position++
 					}
-				l642:
-					goto l618
-				l637:
-					position, tokenIndex = position618, tokenIndex618
+				l626:
+					goto l602
+				l621:
+					position, tokenIndex = position602, tokenIndex602
 					{
-						position645, tokenIndex645 := position, tokenIndex
+						position629, tokenIndex629 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l646
+							goto l630
 						}
 						position++
-						goto l645
-					l646:
-						position, tokenIndex = position645, tokenIndex645
+						goto l629
+					l630:
+						position, tokenIndex = position629, tokenIndex629
 						if buffer[position] != rune('R') {
-							goto l644
+							goto l628
 						}
 						position++
 					}
-				l645:
+				l629:
 					{
-						position647, tokenIndex647 := position, tokenIndex
+						position631, tokenIndex631 := position, tokenIndex
 						if buffer[position] != rune('o') {
-							goto l648
+							goto l632
 						}
 						position++
-						goto l647
-					l648:
-						position, tokenIndex = position647, tokenIndex647
+						goto l631
+					l632:
+						position, tokenIndex = position631, tokenIndex631
 						if buffer[position] != rune('O') {
-							goto l644
+							goto l628
 						}
 						position++
 					}
-				l647:
+				l631:
 					{
-						position649, tokenIndex649 := position, tokenIndex
+						position633, tokenIndex633 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l650
+							goto l634
 						}
 						position++
-						goto l649
-					l650:
-						position, tokenIndex = position649, tokenIndex649
+						goto l633
+					l634:
+						position, tokenIndex = position633, tokenIndex633
 						if buffer[position] != rune('R') {
-							goto l644
+							goto l628
 						}
 						position++
 					}
-				l649:
-					goto l618
-				l644:
-					position, tokenIndex = position618, tokenIndex618
+				l633:
+					goto l602
+				l628:
+					position, tokenIndex = position602, tokenIndex602
 					{
-						position651, tokenIndex651 := position, tokenIndex
+						position635, tokenIndex635 := position, tokenIndex
 						if buffer[position] != rune('a') {
-							goto l652
+							goto l636
 						}
 						position++
-						goto l651
-					l652:
-						position, tokenIndex = position651, tokenIndex651
+						goto l635
+					l636:
+						position, tokenIndex = position635, tokenIndex635
 						if buffer[position] != rune('A') {
-							goto l616
+							goto l600
 						}
 						position++
 					}
-				l651:
+				l635:
 					{
-						position653, tokenIndex653 := position, tokenIndex
+						position637, tokenIndex637 := position, tokenIndex
 						if buffer[position] != rune('s') {
-							goto l654
+							goto l638
 						}
 						position++
-						goto l653
-					l654:
-						position, tokenIndex = position653, tokenIndex653
+						goto l637
+					l638:
+						position, tokenIndex = position637, tokenIndex637
 						if buffer[position] != rune('S') {
-							goto l616
+							goto l600
 						}
 						position++
 					}
-				l653:
+				l637:
 					{
-						position655, tokenIndex655 := position, tokenIndex
+						position639, tokenIndex639 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l656
+							goto l640
 						}
 						position++
-						goto l655
-					l656:
-						position, tokenIndex = position655, tokenIndex655
+						goto l639
+					l640:
+						position, tokenIndex = position639, tokenIndex639
 						if buffer[position] != rune('R') {
-							goto l616
+							goto l600
 						}
 						position++
 					}
-				l655:
+				l639:
 				}
-			l618:
+			l602:
 				{
-					position657, tokenIndex657 := position, tokenIndex
+					position641, tokenIndex641 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l657
+						goto l641
 					}
 					{
-						position659, tokenIndex659 := position, tokenIndex
+						position643, tokenIndex643 := position, tokenIndex
 						if buffer[position] != rune('#') {
-							goto l659
+							goto l643
 						}
 						position++
-						goto l660
-					l659:
-						position, tokenIndex = position659, tokenIndex659
+						goto l644
+					l643:
+						position, tokenIndex = position643, tokenIndex643
 					}
-				l660:
+				l644:
 					if !_rules[ruleOffset]() {
-						goto l657
+						goto l641
 					}
-					goto l658
-				l657:
-					position, tokenIndex = position657, tokenIndex657
+					goto l642
+				l641:
+					position, tokenIndex = position641, tokenIndex641
 				}
-			l658:
-				add(ruleARMConstantTweak, position617)
+			l642:
+				add(ruleARMConstantTweak, position601)
 			}
 			return true
-		l616:
-			position, tokenIndex = position616, tokenIndex616
+		l600:
+			position, tokenIndex = position600, tokenIndex600
 			return false
 		},
-		/* 41 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')) / ARMVectorRegister / ('{' WS? ARMVectorRegister WS? ((',' / '-') WS? ARMVectorRegister)* WS? '}' ('[' [0-9] [0-9]? ']')?))> */
+		/* 43 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')) / ARMVectorRegister / ('{' WS? ARMVectorRegister WS? ((',' / '-') WS? ARMVectorRegister)* WS? '}' ('[' [0-9] [0-9]? ']')?))> */
 		func() bool {
-			position661, tokenIndex661 := position, tokenIndex
+			position645, tokenIndex645 := position, tokenIndex
 			{
-				position662 := position
+				position646 := position
 				{
-					position663, tokenIndex663 := position, tokenIndex
+					position647, tokenIndex647 := position, tokenIndex
 					{
-						position665, tokenIndex665 := position, tokenIndex
+						position649, tokenIndex649 := position, tokenIndex
 						if buffer[position] != rune('s') {
-							goto l666
+							goto l650
 						}
 						position++
-						goto l665
-					l666:
-						position, tokenIndex = position665, tokenIndex665
+						goto l649
+					l650:
+						position, tokenIndex = position649, tokenIndex649
 						if buffer[position] != rune('S') {
-							goto l664
+							goto l648
 						}
 						position++
 					}
-				l665:
+				l649:
 					{
-						position667, tokenIndex667 := position, tokenIndex
+						position651, tokenIndex651 := position, tokenIndex
 						if buffer[position] != rune('p') {
-							goto l668
+							goto l652
 						}
 						position++
-						goto l667
-					l668:
-						position, tokenIndex = position667, tokenIndex667
+						goto l651
+					l652:
+						position, tokenIndex = position651, tokenIndex651
 						if buffer[position] != rune('P') {
-							goto l664
+							goto l648
 						}
 						position++
 					}
-				l667:
-					goto l663
-				l664:
-					position, tokenIndex = position663, tokenIndex663
+				l651:
+					goto l647
+				l648:
+					position, tokenIndex = position647, tokenIndex647
 					{
-						position670, tokenIndex670 := position, tokenIndex
+						position654, tokenIndex654 := position, tokenIndex
 						if buffer[position] != rune('x') {
-							goto l671
+							goto l655
 						}
 						position++
-						goto l670
-					l671:
-						position, tokenIndex = position670, tokenIndex670
+						goto l654
+					l655:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('w') {
-							goto l672
+							goto l656
 						}
 						position++
-						goto l670
-					l672:
-						position, tokenIndex = position670, tokenIndex670
+						goto l654
+					l656:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('d') {
-							goto l673
+							goto l657
 						}
 						position++
-						goto l670
-					l673:
-						position, tokenIndex = position670, tokenIndex670
+						goto l654
+					l657:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('q') {
-							goto l674
+							goto l658
 						}
 						position++
-						goto l670
-					l674:
-						position, tokenIndex = position670, tokenIndex670
+						goto l654
+					l658:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('s') {
-							goto l675
+							goto l659
 						}
 						position++
-						goto l670
-					l675:
-						position, tokenIndex = position670, tokenIndex670
+						goto l654
+					l659:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('h') {
-							goto l676
+							goto l660
 						}
 						position++
-						goto l670
-					l676:
-						position, tokenIndex = position670, tokenIndex670
+						goto l654
+					l660:
+						position, tokenIndex = position654, tokenIndex654
 						if buffer[position] != rune('b') {
-							goto l669
+							goto l653
 						}
 						position++
 					}
-				l670:
+				l654:
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l669
+						goto l653
 					}
 					position++
 					{
-						position677, tokenIndex677 := position, tokenIndex
+						position661, tokenIndex661 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l677
+							goto l661
 						}
 						position++
-						goto l678
-					l677:
-						position, tokenIndex = position677, tokenIndex677
+						goto l662
+					l661:
+						position, tokenIndex = position661, tokenIndex661
 					}
-				l678:
-					goto l663
-				l669:
-					position, tokenIndex = position663, tokenIndex663
+				l662:
+					goto l647
+				l653:
+					position, tokenIndex = position647, tokenIndex647
 					{
-						position680, tokenIndex680 := position, tokenIndex
+						position664, tokenIndex664 := position, tokenIndex
 						if buffer[position] != rune('x') {
-							goto l681
+							goto l665
 						}
 						position++
-						goto l680
-					l681:
-						position, tokenIndex = position680, tokenIndex680
+						goto l664
+					l665:
+						position, tokenIndex = position664, tokenIndex664
 						if buffer[position] != rune('X') {
-							goto l679
+							goto l663
 						}
 						position++
 					}
-				l680:
+				l664:
 					{
-						position682, tokenIndex682 := position, tokenIndex
+						position666, tokenIndex666 := position, tokenIndex
 						if buffer[position] != rune('z') {
-							goto l683
+							goto l667
 						}
 						position++
-						goto l682
-					l683:
-						position, tokenIndex = position682, tokenIndex682
+						goto l666
+					l667:
+						position, tokenIndex = position666, tokenIndex666
 						if buffer[position] != rune('Z') {
-							goto l679
+							goto l663
 						}
 						position++
 					}
-				l682:
+				l666:
 					{
-						position684, tokenIndex684 := position, tokenIndex
+						position668, tokenIndex668 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l685
+							goto l669
 						}
 						position++
-						goto l684
-					l685:
-						position, tokenIndex = position684, tokenIndex684
+						goto l668
+					l669:
+						position, tokenIndex = position668, tokenIndex668
 						if buffer[position] != rune('R') {
-							goto l679
+							goto l663
 						}
 						position++
 					}
-				l684:
-					goto l663
-				l679:
-					position, tokenIndex = position663, tokenIndex663
+				l668:
+					goto l647
+				l663:
+					position, tokenIndex = position647, tokenIndex647
 					{
-						position687, tokenIndex687 := position, tokenIndex
+						position671, tokenIndex671 := position, tokenIndex
 						if buffer[position] != rune('w') {
-							goto l688
+							goto l672
 						}
 						position++
-						goto l687
-					l688:
-						position, tokenIndex = position687, tokenIndex687
+						goto l671
+					l672:
+						position, tokenIndex = position671, tokenIndex671
 						if buffer[position] != rune('W') {
-							goto l686
+							goto l670
 						}
 						position++
 					}
-				l687:
+				l671:
 					{
-						position689, tokenIndex689 := position, tokenIndex
+						position673, tokenIndex673 := position, tokenIndex
 						if buffer[position] != rune('z') {
-							goto l690
+							goto l674
 						}
 						position++
-						goto l689
-					l690:
-						position, tokenIndex = position689, tokenIndex689
+						goto l673
+					l674:
+						position, tokenIndex = position673, tokenIndex673
 						if buffer[position] != rune('Z') {
-							goto l686
+							goto l670
 						}
 						position++
 					}
-				l689:
+				l673:
 					{
-						position691, tokenIndex691 := position, tokenIndex
+						position675, tokenIndex675 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l692
+							goto l676
 						}
 						position++
-						goto l691
-					l692:
-						position, tokenIndex = position691, tokenIndex691
+						goto l675
+					l676:
+						position, tokenIndex = position675, tokenIndex675
 						if buffer[position] != rune('R') {
-							goto l686
+							goto l670
 						}
 						position++
 					}
-				l691:
-					goto l663
-				l686:
-					position, tokenIndex = position663, tokenIndex663
+				l675:
+					goto l647
+				l670:
+					position, tokenIndex = position647, tokenIndex647
 					{
-						position694, tokenIndex694 := position, tokenIndex
+						position678, tokenIndex678 := position, tokenIndex
 						if buffer[position] != rune('n') {
-							goto l695
+							goto l679
 						}
 						position++
-						goto l694
-					l695:
-						position, tokenIndex = position694, tokenIndex694
+						goto l678
+					l679:
+						position, tokenIndex = position678, tokenIndex678
 						if buffer[position] != rune('N') {
-							goto l693
+							goto l677
 						}
 						position++
 					}
-				l694:
+				l678:
 					{
-						position696, tokenIndex696 := position, tokenIndex
+						position680, tokenIndex680 := position, tokenIndex
 						if buffer[position] != rune('z') {
-							goto l697
+							goto l681
 						}
 						position++
-						goto l696
-					l697:
-						position, tokenIndex = position696, tokenIndex696
+						goto l680
+					l681:
+						position, tokenIndex = position680, tokenIndex680
 						if buffer[position] != rune('Z') {
-							goto l693
+							goto l677
 						}
 						position++
 					}
-				l696:
+				l680:
 					{
-						position698, tokenIndex698 := position, tokenIndex
+						position682, tokenIndex682 := position, tokenIndex
 						if buffer[position] != rune('c') {
-							goto l699
+							goto l683
 						}
 						position++
-						goto l698
-					l699:
-						position, tokenIndex = position698, tokenIndex698
+						goto l682
+					l683:
+						position, tokenIndex = position682, tokenIndex682
 						if buffer[position] != rune('C') {
-							goto l693
+							goto l677
 						}
 						position++
 					}
-				l698:
+				l682:
 					{
-						position700, tokenIndex700 := position, tokenIndex
+						position684, tokenIndex684 := position, tokenIndex
 						if buffer[position] != rune('v') {
-							goto l701
+							goto l685
 						}
 						position++
-						goto l700
-					l701:
-						position, tokenIndex = position700, tokenIndex700
+						goto l684
+					l685:
+						position, tokenIndex = position684, tokenIndex684
 						if buffer[position] != rune('V') {
-							goto l693
+							goto l677
 						}
 						position++
 					}
-				l700:
-					goto l663
-				l693:
-					position, tokenIndex = position663, tokenIndex663
+				l684:
+					goto l647
+				l677:
+					position, tokenIndex = position647, tokenIndex647
 					if !_rules[ruleARMVectorRegister]() {
-						goto l702
+						goto l686
 					}
-					goto l663
-				l702:
-					position, tokenIndex = position663, tokenIndex663
+					goto l647
+				l686:
+					position, tokenIndex = position647, tokenIndex647
 					if buffer[position] != rune('{') {
-						goto l661
+						goto l645
 					}
 					position++
 					{
-						position703, tokenIndex703 := position, tokenIndex
+						position687, tokenIndex687 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l703
+							goto l687
 						}
-						goto l704
-					l703:
-						position, tokenIndex = position703, tokenIndex703
+						goto l688
+					l687:
+						position, tokenIndex = position687, tokenIndex687
 					}
-				l704:
+				l688:
 					if !_rules[ruleARMVectorRegister]() {
-						goto l661
+						goto l645
 					}
 					{
-						position705, tokenIndex705 := position, tokenIndex
+						position689, tokenIndex689 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l705
+							goto l689
 						}
-						goto l706
-					l705:
-						position, tokenIndex = position705, tokenIndex705
+						goto l690
+					l689:
+						position, tokenIndex = position689, tokenIndex689
 					}
-				l706:
-				l707:
+				l690:
+				l691:
 					{
-						position708, tokenIndex708 := position, tokenIndex
+						position692, tokenIndex692 := position, tokenIndex
 						{
-							position709, tokenIndex709 := position, tokenIndex
+							position693, tokenIndex693 := position, tokenIndex
 							if buffer[position] != rune(',') {
-								goto l710
+								goto l694
 							}
 							position++
-							goto l709
-						l710:
-							position, tokenIndex = position709, tokenIndex709
+							goto l693
+						l694:
+							position, tokenIndex = position693, tokenIndex693
 							if buffer[position] != rune('-') {
-								goto l708
+								goto l692
 							}
 							position++
 						}
-					l709:
+					l693:
 						{
-							position711, tokenIndex711 := position, tokenIndex
+							position695, tokenIndex695 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l711
+								goto l695
 							}
-							goto l712
-						l711:
-							position, tokenIndex = position711, tokenIndex711
+							goto l696
+						l695:
+							position, tokenIndex = position695, tokenIndex695
 						}
-					l712:
+					l696:
 						if !_rules[ruleARMVectorRegister]() {
-							goto l708
+							goto l692
 						}
-						goto l707
-					l708:
-						position, tokenIndex = position708, tokenIndex708
+						goto l691
+					l692:
+						position, tokenIndex = position692, tokenIndex692
 					}
 					{
-						position713, tokenIndex713 := position, tokenIndex
+						position697, tokenIndex697 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l713
+							goto l697
 						}
-						goto l714
-					l713:
-						position, tokenIndex = position713, tokenIndex713
+						goto l698
+					l697:
+						position, tokenIndex = position697, tokenIndex697
 					}
-				l714:
+				l698:
 					if buffer[position] != rune('}') {
-						goto l661
+						goto l645
 					}
 					position++
 					{
-						position715, tokenIndex715 := position, tokenIndex
+						position699, tokenIndex699 := position, tokenIndex
 						if buffer[position] != rune('[') {
-							goto l715
+							goto l699
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l715
+							goto l699
 						}
 						position++
 						{
-							position717, tokenIndex717 := position, tokenIndex
+							position701, tokenIndex701 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l717
+								goto l701
 							}
 							position++
-							goto l718
-						l717:
-							position, tokenIndex = position717, tokenIndex717
+							goto l702
+						l701:
+							position, tokenIndex = position701, tokenIndex701
 						}
-					l718:
+					l702:
 						if buffer[position] != rune(']') {
-							goto l715
+							goto l699
 						}
 						position++
-						goto l716
-					l715:
-						position, tokenIndex = position715, tokenIndex715
+						goto l700
+					l699:
+						position, tokenIndex = position699, tokenIndex699
 					}
-				l716:
+				l700:
 				}
-			l663:
-				add(ruleARMRegister, position662)
+			l647:
+				add(ruleARMRegister, position646)
 			}
 			return true
-		l661:
-			position, tokenIndex = position661, tokenIndex661
+		l645:
+			position, tokenIndex = position645, tokenIndex645
 			return false
 		},
-		/* 42 ARMVectorRegister <- <(('v' / 'V') [0-9] [0-9]? ('.' [0-9]* ('b' / 's' / 'd' / 'h' / 'q') ('[' [0-9] [0-9]? ']')?)?)> */
+		/* 44 ARMVectorRegister <- <(('v' / 'V') [0-9] [0-9]? ('.' [0-9]* ('b' / 's' / 'd' / 'h' / 'q') ('[' [0-9] [0-9]? ']')?)?)> */
 		func() bool {
-			position719, tokenIndex719 := position, tokenIndex
+			position703, tokenIndex703 := position, tokenIndex
 			{
-				position720 := position
+				position704 := position
 				{
-					position721, tokenIndex721 := position, tokenIndex
+					position705, tokenIndex705 := position, tokenIndex
 					if buffer[position] != rune('v') {
-						goto l722
+						goto l706
 					}
 					position++
-					goto l721
-				l722:
-					position, tokenIndex = position721, tokenIndex721
+					goto l705
+				l706:
+					position, tokenIndex = position705, tokenIndex705
 					if buffer[position] != rune('V') {
-						goto l719
+						goto l703
 					}
 					position++
 				}
-			l721:
+			l705:
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l719
+					goto l703
 				}
 				position++
 				{
-					position723, tokenIndex723 := position, tokenIndex
+					position707, tokenIndex707 := position, tokenIndex
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l723
+						goto l707
 					}
 					position++
-					goto l724
-				l723:
-					position, tokenIndex = position723, tokenIndex723
+					goto l708
+				l707:
+					position, tokenIndex = position707, tokenIndex707
 				}
-			l724:
+			l708:
 				{
-					position725, tokenIndex725 := position, tokenIndex
+					position709, tokenIndex709 := position, tokenIndex
 					if buffer[position] != rune('.') {
-						goto l725
+						goto l709
 					}
 					position++
-				l727:
+				l711:
 					{
-						position728, tokenIndex728 := position, tokenIndex
+						position712, tokenIndex712 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l728
+							goto l712
 						}
 						position++
-						goto l727
-					l728:
-						position, tokenIndex = position728, tokenIndex728
+						goto l711
+					l712:
+						position, tokenIndex = position712, tokenIndex712
 					}
 					{
-						position729, tokenIndex729 := position, tokenIndex
+						position713, tokenIndex713 := position, tokenIndex
 						if buffer[position] != rune('b') {
-							goto l730
+							goto l714
 						}
 						position++
-						goto l729
-					l730:
-						position, tokenIndex = position729, tokenIndex729
+						goto l713
+					l714:
+						position, tokenIndex = position713, tokenIndex713
 						if buffer[position] != rune('s') {
-							goto l731
+							goto l715
 						}
 						position++
-						goto l729
-					l731:
-						position, tokenIndex = position729, tokenIndex729
+						goto l713
+					l715:
+						position, tokenIndex = position713, tokenIndex713
 						if buffer[position] != rune('d') {
-							goto l732
+							goto l716
 						}
 						position++
-						goto l729
-					l732:
-						position, tokenIndex = position729, tokenIndex729
+						goto l713
+					l716:
+						position, tokenIndex = position713, tokenIndex713
 						if buffer[position] != rune('h') {
-							goto l733
+							goto l717
 						}
 						position++
-						goto l729
-					l733:
-						position, tokenIndex = position729, tokenIndex729
+						goto l713
+					l717:
+						position, tokenIndex = position713, tokenIndex713
 						if buffer[position] != rune('q') {
-							goto l725
+							goto l709
 						}
 						position++
 					}
-				l729:
+				l713:
 					{
-						position734, tokenIndex734 := position, tokenIndex
+						position718, tokenIndex718 := position, tokenIndex
 						if buffer[position] != rune('[') {
-							goto l734
+							goto l718
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l734
+							goto l718
 						}
 						position++
 						{
-							position736, tokenIndex736 := position, tokenIndex
+							position720, tokenIndex720 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l736
+								goto l720
 							}
 							position++
-							goto l737
-						l736:
-							position, tokenIndex = position736, tokenIndex736
+							goto l721
+						l720:
+							position, tokenIndex = position720, tokenIndex720
 						}
-					l737:
+					l721:
 						if buffer[position] != rune(']') {
-							goto l734
+							goto l718
 						}
 						position++
-						goto l735
-					l734:
-						position, tokenIndex = position734, tokenIndex734
+						goto l719
+					l718:
+						position, tokenIndex = position718, tokenIndex718
 					}
-				l735:
-					goto l726
-				l725:
-					position, tokenIndex = position725, tokenIndex725
+				l719:
+					goto l710
+				l709:
+					position, tokenIndex = position709, tokenIndex709
 				}
-			l726:
-				add(ruleARMVectorRegister, position720)
+			l710:
+				add(ruleARMVectorRegister, position704)
 			}
 			return true
-		l719:
-			position, tokenIndex = position719, tokenIndex719
+		l703:
+			position, tokenIndex = position703, tokenIndex703
 			return false
 		},
-		/* 43 MemoryRef <- <((SymbolRef BaseIndexScale) / SymbolRef / Low12BitsSymbolRef / (Offset* BaseIndexScale) / (SegmentRegister Offset BaseIndexScale) / (SegmentRegister BaseIndexScale) / (SegmentRegister Offset) / ARMBaseIndexScale / BaseIndexScale)> */
+		/* 45 MemoryRef <- <((SymbolRef BaseIndexScale) / SymbolRef / Low12BitsSymbolRef / (Offset* BaseIndexScale) / (SegmentRegister Offset BaseIndexScale) / (SegmentRegister BaseIndexScale) / (SegmentRegister Offset) / ARMBaseIndexScale / BaseIndexScale)> */
 		func() bool {
-			position738, tokenIndex738 := position, tokenIndex
+			position722, tokenIndex722 := position, tokenIndex
 			{
-				position739 := position
+				position723 := position
 				{
-					position740, tokenIndex740 := position, tokenIndex
+					position724, tokenIndex724 := position, tokenIndex
 					if !_rules[ruleSymbolRef]() {
-						goto l741
+						goto l725
 					}
 					if !_rules[ruleBaseIndexScale]() {
-						goto l741
+						goto l725
 					}
-					goto l740
-				l741:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l725:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleSymbolRef]() {
-						goto l742
+						goto l726
 					}
-					goto l740
-				l742:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l726:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleLow12BitsSymbolRef]() {
-						goto l743
+						goto l727
 					}
-					goto l740
-				l743:
-					position, tokenIndex = position740, tokenIndex740
-				l745:
+					goto l724
+				l727:
+					position, tokenIndex = position724, tokenIndex724
+				l729:
 					{
-						position746, tokenIndex746 := position, tokenIndex
+						position730, tokenIndex730 := position, tokenIndex
 						if !_rules[ruleOffset]() {
-							goto l746
+							goto l730
 						}
-						goto l745
-					l746:
-						position, tokenIndex = position746, tokenIndex746
+						goto l729
+					l730:
+						position, tokenIndex = position730, tokenIndex730
 					}
 					if !_rules[ruleBaseIndexScale]() {
-						goto l744
+						goto l728
 					}
-					goto l740
-				l744:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l728:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleSegmentRegister]() {
-						goto l747
+						goto l731
 					}
 					if !_rules[ruleOffset]() {
-						goto l747
+						goto l731
 					}
 					if !_rules[ruleBaseIndexScale]() {
-						goto l747
+						goto l731
 					}
-					goto l740
-				l747:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l731:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleSegmentRegister]() {
-						goto l748
+						goto l732
 					}
 					if !_rules[ruleBaseIndexScale]() {
-						goto l748
+						goto l732
 					}
-					goto l740
-				l748:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l732:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleSegmentRegister]() {
-						goto l749
+						goto l733
 					}
 					if !_rules[ruleOffset]() {
-						goto l749
+						goto l733
 					}
-					goto l740
-				l749:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l733:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleARMBaseIndexScale]() {
-						goto l750
+						goto l734
 					}
-					goto l740
-				l750:
-					position, tokenIndex = position740, tokenIndex740
+					goto l724
+				l734:
+					position, tokenIndex = position724, tokenIndex724
 					if !_rules[ruleBaseIndexScale]() {
-						goto l738
+						goto l722
 					}
 				}
-			l740:
-				add(ruleMemoryRef, position739)
+			l724:
+				add(ruleMemoryRef, position723)
 			}
 			return true
-		l738:
-			position, tokenIndex = position738, tokenIndex738
+		l722:
+			position, tokenIndex = position722, tokenIndex722
 			return false
 		},
-		/* 44 SymbolRef <- <((Offset* '+')? (LocalSymbol / SymbolName) Offset* ('@' Section Offset*)?)> */
+		/* 46 SymbolRef <- <((Offset* '+')? (LocalSymbol / SymbolName) Offset* ('@' Section Offset*)?)> */
 		func() bool {
-			position751, tokenIndex751 := position, tokenIndex
+			position735, tokenIndex735 := position, tokenIndex
 			{
-				position752 := position
+				position736 := position
 				{
-					position753, tokenIndex753 := position, tokenIndex
-				l755:
+					position737, tokenIndex737 := position, tokenIndex
+				l739:
 					{
-						position756, tokenIndex756 := position, tokenIndex
+						position740, tokenIndex740 := position, tokenIndex
 						if !_rules[ruleOffset]() {
-							goto l756
+							goto l740
 						}
-						goto l755
-					l756:
-						position, tokenIndex = position756, tokenIndex756
+						goto l739
+					l740:
+						position, tokenIndex = position740, tokenIndex740
 					}
 					if buffer[position] != rune('+') {
-						goto l753
+						goto l737
 					}
 					position++
-					goto l754
-				l753:
-					position, tokenIndex = position753, tokenIndex753
+					goto l738
+				l737:
+					position, tokenIndex = position737, tokenIndex737
 				}
-			l754:
+			l738:
 				{
-					position757, tokenIndex757 := position, tokenIndex
+					position741, tokenIndex741 := position, tokenIndex
 					if !_rules[ruleLocalSymbol]() {
-						goto l758
+						goto l742
 					}
-					goto l757
-				l758:
-					position, tokenIndex = position757, tokenIndex757
+					goto l741
+				l742:
+					position, tokenIndex = position741, tokenIndex741
 					if !_rules[ruleSymbolName]() {
-						goto l751
+						goto l735
 					}
 				}
-			l757:
-			l759:
+			l741:
+			l743:
 				{
-					position760, tokenIndex760 := position, tokenIndex
+					position744, tokenIndex744 := position, tokenIndex
 					if !_rules[ruleOffset]() {
-						goto l760
+						goto l744
 					}
-					goto l759
-				l760:
-					position, tokenIndex = position760, tokenIndex760
+					goto l743
+				l744:
+					position, tokenIndex = position744, tokenIndex744
 				}
 				{
-					position761, tokenIndex761 := position, tokenIndex
+					position745, tokenIndex745 := position, tokenIndex
 					if buffer[position] != rune('@') {
-						goto l761
+						goto l745
 					}
 					position++
 					if !_rules[ruleSection]() {
-						goto l761
+						goto l745
 					}
-				l763:
+				l747:
 					{
-						position764, tokenIndex764 := position, tokenIndex
+						position748, tokenIndex748 := position, tokenIndex
 						if !_rules[ruleOffset]() {
-							goto l764
+							goto l748
 						}
-						goto l763
-					l764:
-						position, tokenIndex = position764, tokenIndex764
+						goto l747
+					l748:
+						position, tokenIndex = position748, tokenIndex748
 					}
-					goto l762
-				l761:
-					position, tokenIndex = position761, tokenIndex761
+					goto l746
+				l745:
+					position, tokenIndex = position745, tokenIndex745
 				}
-			l762:
-				add(ruleSymbolRef, position752)
+			l746:
+				add(ruleSymbolRef, position736)
 			}
 			return true
-		l751:
-			position, tokenIndex = position751, tokenIndex751
+		l735:
+			position, tokenIndex = position735, tokenIndex735
 			return false
 		},
-		/* 45 Low12BitsSymbolRef <- <(':' ('l' / 'L') ('o' / 'O') '1' '2' ':' (LocalSymbol / SymbolName) Offset?)> */
+		/* 47 Low12BitsSymbolRef <- <(':' ('l' / 'L') ('o' / 'O') '1' '2' ':' (LocalSymbol / SymbolName) Offset?)> */
 		func() bool {
-			position765, tokenIndex765 := position, tokenIndex
+			position749, tokenIndex749 := position, tokenIndex
 			{
-				position766 := position
+				position750 := position
 				if buffer[position] != rune(':') {
-					goto l765
+					goto l749
 				}
 				position++
 				{
-					position767, tokenIndex767 := position, tokenIndex
+					position751, tokenIndex751 := position, tokenIndex
 					if buffer[position] != rune('l') {
-						goto l768
+						goto l752
 					}
 					position++
-					goto l767
-				l768:
-					position, tokenIndex = position767, tokenIndex767
+					goto l751
+				l752:
+					position, tokenIndex = position751, tokenIndex751
 					if buffer[position] != rune('L') {
-						goto l765
+						goto l749
 					}
 					position++
 				}
-			l767:
+			l751:
 				{
-					position769, tokenIndex769 := position, tokenIndex
+					position753, tokenIndex753 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l770
+						goto l754
 					}
 					position++
-					goto l769
-				l770:
-					position, tokenIndex = position769, tokenIndex769
+					goto l753
+				l754:
+					position, tokenIndex = position753, tokenIndex753
 					if buffer[position] != rune('O') {
-						goto l765
+						goto l749
 					}
 					position++
 				}
-			l769:
+			l753:
 				if buffer[position] != rune('1') {
-					goto l765
+					goto l749
 				}
 				position++
 				if buffer[position] != rune('2') {
-					goto l765
+					goto l749
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l765
+					goto l749
 				}
 				position++
 				{
-					position771, tokenIndex771 := position, tokenIndex
+					position755, tokenIndex755 := position, tokenIndex
 					if !_rules[ruleLocalSymbol]() {
-						goto l772
+						goto l756
 					}
-					goto l771
-				l772:
-					position, tokenIndex = position771, tokenIndex771
+					goto l755
+				l756:
+					position, tokenIndex = position755, tokenIndex755
 					if !_rules[ruleSymbolName]() {
-						goto l765
+						goto l749
 					}
 				}
-			l771:
+			l755:
 				{
-					position773, tokenIndex773 := position, tokenIndex
+					position757, tokenIndex757 := position, tokenIndex
 					if !_rules[ruleOffset]() {
-						goto l773
+						goto l757
 					}
-					goto l774
-				l773:
-					position, tokenIndex = position773, tokenIndex773
+					goto l758
+				l757:
+					position, tokenIndex = position757, tokenIndex757
 				}
-			l774:
-				add(ruleLow12BitsSymbolRef, position766)
+			l758:
+				add(ruleLow12BitsSymbolRef, position750)
 			}
 			return true
-		l765:
-			position, tokenIndex = position765, tokenIndex765
+		l749:
+			position, tokenIndex = position749, tokenIndex749
 			return false
 		},
-		/* 46 ARMBaseIndexScale <- <('[' ARMRegister (',' WS? (('#'? Offset (('*' [0-9]+) / ('*' '(' [0-9]+ Operator [0-9]+ ')') / ('+' [0-9]+)*)?) / ('#'? ARMGOTLow12) / ('#'? Low12BitsSymbolRef) / ARMRegister) (',' WS? ARMConstantTweak)?)? ']' ARMPostincrement?)> */
+		/* 48 ARMBaseIndexScale <- <('[' ARMRegister (',' WS? (('#'? Offset (('*' [0-9]+) / ('*' '(' [0-9]+ Operator [0-9]+ ')') / ('+' [0-9]+)*)?) / ('#'? ARMGOTLow12) / ('#'? Low12BitsSymbolRef) / ARMRegister) (',' WS? ARMConstantTweak)?)? ']' ARMPostincrement?)> */
 		func() bool {
-			position775, tokenIndex775 := position, tokenIndex
+			position759, tokenIndex759 := position, tokenIndex
 			{
-				position776 := position
+				position760 := position
 				if buffer[position] != rune('[') {
-					goto l775
+					goto l759
 				}
 				position++
 				if !_rules[ruleARMRegister]() {
-					goto l775
+					goto l759
 				}
 				{
-					position777, tokenIndex777 := position, tokenIndex
+					position761, tokenIndex761 := position, tokenIndex
 					if buffer[position] != rune(',') {
-						goto l777
+						goto l761
 					}
 					position++
 					{
-						position779, tokenIndex779 := position, tokenIndex
+						position763, tokenIndex763 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l779
+							goto l763
 						}
-						goto l780
-					l779:
-						position, tokenIndex = position779, tokenIndex779
+						goto l764
+					l763:
+						position, tokenIndex = position763, tokenIndex763
 					}
-				l780:
+				l764:
 					{
-						position781, tokenIndex781 := position, tokenIndex
+						position765, tokenIndex765 := position, tokenIndex
 						{
-							position783, tokenIndex783 := position, tokenIndex
+							position767, tokenIndex767 := position, tokenIndex
 							if buffer[position] != rune('#') {
-								goto l783
+								goto l767
 							}
 							position++
-							goto l784
-						l783:
-							position, tokenIndex = position783, tokenIndex783
+							goto l768
+						l767:
+							position, tokenIndex = position767, tokenIndex767
 						}
-					l784:
+					l768:
 						if !_rules[ruleOffset]() {
-							goto l782
+							goto l766
 						}
 						{
-							position785, tokenIndex785 := position, tokenIndex
+							position769, tokenIndex769 := position, tokenIndex
 							{
-								position787, tokenIndex787 := position, tokenIndex
+								position771, tokenIndex771 := position, tokenIndex
 								if buffer[position] != rune('*') {
-									goto l788
+									goto l772
 								}
 								position++
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l788
+									goto l772
 								}
 								position++
-							l789:
+							l773:
 								{
-									position790, tokenIndex790 := position, tokenIndex
+									position774, tokenIndex774 := position, tokenIndex
 									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l790
+										goto l774
 									}
 									position++
-									goto l789
-								l790:
-									position, tokenIndex = position790, tokenIndex790
+									goto l773
+								l774:
+									position, tokenIndex = position774, tokenIndex774
 								}
-								goto l787
-							l788:
-								position, tokenIndex = position787, tokenIndex787
+								goto l771
+							l772:
+								position, tokenIndex = position771, tokenIndex771
 								if buffer[position] != rune('*') {
-									goto l791
+									goto l775
 								}
 								position++
 								if buffer[position] != rune('(') {
-									goto l791
+									goto l775
 								}
 								position++
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l791
+									goto l775
 								}
 								position++
-							l792:
+							l776:
 								{
-									position793, tokenIndex793 := position, tokenIndex
+									position777, tokenIndex777 := position, tokenIndex
 									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l793
+										goto l777
 									}
 									position++
-									goto l792
-								l793:
-									position, tokenIndex = position793, tokenIndex793
+									goto l776
+								l777:
+									position, tokenIndex = position777, tokenIndex777
 								}
 								if !_rules[ruleOperator]() {
-									goto l791
+									goto l775
 								}
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l791
+									goto l775
 								}
 								position++
-							l794:
+							l778:
 								{
-									position795, tokenIndex795 := position, tokenIndex
+									position779, tokenIndex779 := position, tokenIndex
 									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l795
+										goto l779
 									}
 									position++
-									goto l794
-								l795:
-									position, tokenIndex = position795, tokenIndex795
+									goto l778
+								l779:
+									position, tokenIndex = position779, tokenIndex779
 								}
 								if buffer[position] != rune(')') {
-									goto l791
+									goto l775
 								}
 								position++
-								goto l787
-							l791:
-								position, tokenIndex = position787, tokenIndex787
-							l796:
+								goto l771
+							l775:
+								position, tokenIndex = position771, tokenIndex771
+							l780:
 								{
-									position797, tokenIndex797 := position, tokenIndex
+									position781, tokenIndex781 := position, tokenIndex
 									if buffer[position] != rune('+') {
-										goto l797
+										goto l781
 									}
 									position++
 									if c := buffer[position]; c < rune('0') || c > rune('9') {
-										goto l797
+										goto l781
 									}
 									position++
-								l798:
+								l782:
 									{
-										position799, tokenIndex799 := position, tokenIndex
+										position783, tokenIndex783 := position, tokenIndex
 										if c := buffer[position]; c < rune('0') || c > rune('9') {
-											goto l799
+											goto l783
 										}
 										position++
-										goto l798
-									l799:
-										position, tokenIndex = position799, tokenIndex799
+										goto l782
+									l783:
+										position, tokenIndex = position783, tokenIndex783
 									}
-									goto l796
-								l797:
-									position, tokenIndex = position797, tokenIndex797
+									goto l780
+								l781:
+									position, tokenIndex = position781, tokenIndex781
 								}
 							}
-						l787:
-							goto l786
+						l771:
+							goto l770
 
-							position, tokenIndex = position785, tokenIndex785
+							position, tokenIndex = position769, tokenIndex769
 						}
-					l786:
-						goto l781
-					l782:
-						position, tokenIndex = position781, tokenIndex781
+					l770:
+						goto l765
+					l766:
+						position, tokenIndex = position765, tokenIndex765
 						{
-							position801, tokenIndex801 := position, tokenIndex
+							position785, tokenIndex785 := position, tokenIndex
 							if buffer[position] != rune('#') {
-								goto l801
+								goto l785
 							}
 							position++
-							goto l802
-						l801:
-							position, tokenIndex = position801, tokenIndex801
+							goto l786
+						l785:
+							position, tokenIndex = position785, tokenIndex785
 						}
-					l802:
+					l786:
 						if !_rules[ruleARMGOTLow12]() {
-							goto l800
+							goto l784
 						}
-						goto l781
-					l800:
-						position, tokenIndex = position781, tokenIndex781
+						goto l765
+					l784:
+						position, tokenIndex = position765, tokenIndex765
 						{
-							position804, tokenIndex804 := position, tokenIndex
+							position788, tokenIndex788 := position, tokenIndex
 							if buffer[position] != rune('#') {
-								goto l804
+								goto l788
 							}
 							position++
-							goto l805
-						l804:
-							position, tokenIndex = position804, tokenIndex804
+							goto l789
+						l788:
+							position, tokenIndex = position788, tokenIndex788
 						}
-					l805:
+					l789:
 						if !_rules[ruleLow12BitsSymbolRef]() {
-							goto l803
+							goto l787
 						}
-						goto l781
-					l803:
-						position, tokenIndex = position781, tokenIndex781
+						goto l765
+					l787:
+						position, tokenIndex = position765, tokenIndex765
 						if !_rules[ruleARMRegister]() {
-							goto l777
+							goto l761
 						}
 					}
-				l781:
+				l765:
 					{
-						position806, tokenIndex806 := position, tokenIndex
+						position790, tokenIndex790 := position, tokenIndex
 						if buffer[position] != rune(',') {
-							goto l806
+							goto l790
 						}
 						position++
 						{
-							position808, tokenIndex808 := position, tokenIndex
+							position792, tokenIndex792 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l808
+								goto l792
 							}
-							goto l809
-						l808:
-							position, tokenIndex = position808, tokenIndex808
+							goto l793
+						l792:
+							position, tokenIndex = position792, tokenIndex792
 						}
-					l809:
+					l793:
 						if !_rules[ruleARMConstantTweak]() {
-							goto l806
+							goto l790
 						}
-						goto l807
-					l806:
-						position, tokenIndex = position806, tokenIndex806
+						goto l791
+					l790:
+						position, tokenIndex = position790, tokenIndex790
 					}
-				l807:
-					goto l778
-				l777:
-					position, tokenIndex = position777, tokenIndex777
+				l791:
+					goto l762
+				l761:
+					position, tokenIndex = position761, tokenIndex761
 				}
-			l778:
+			l762:
 				if buffer[position] != rune(']') {
-					goto l775
+					goto l759
 				}
 				position++
 				{
-					position810, tokenIndex810 := position, tokenIndex
+					position794, tokenIndex794 := position, tokenIndex
 					if !_rules[ruleARMPostincrement]() {
-						goto l810
+						goto l794
 					}
-					goto l811
-				l810:
-					position, tokenIndex = position810, tokenIndex810
+					goto l795
+				l794:
+					position, tokenIndex = position794, tokenIndex794
 				}
-			l811:
-				add(ruleARMBaseIndexScale, position776)
+			l795:
+				add(ruleARMBaseIndexScale, position760)
 			}
 			return true
-		l775:
-			position, tokenIndex = position775, tokenIndex775
+		l759:
+			position, tokenIndex = position759, tokenIndex759
 			return false
 		},
-		/* 47 ARMGOTLow12 <- <(':' ('g' / 'G') ('o' / 'O') ('t' / 'T') '_' ('l' / 'L') ('o' / 'O') '1' '2' ':' SymbolName)> */
+		/* 49 ARMGOTLow12 <- <(':' ('g' / 'G') ('o' / 'O') ('t' / 'T') '_' ('l' / 'L') ('o' / 'O') '1' '2' ':' SymbolName)> */
 		func() bool {
-			position812, tokenIndex812 := position, tokenIndex
+			position796, tokenIndex796 := position, tokenIndex
 			{
-				position813 := position
+				position797 := position
 				if buffer[position] != rune(':') {
-					goto l812
+					goto l796
 				}
 				position++
 				{
-					position814, tokenIndex814 := position, tokenIndex
+					position798, tokenIndex798 := position, tokenIndex
 					if buffer[position] != rune('g') {
-						goto l815
+						goto l799
 					}
 					position++
-					goto l814
-				l815:
-					position, tokenIndex = position814, tokenIndex814
+					goto l798
+				l799:
+					position, tokenIndex = position798, tokenIndex798
 					if buffer[position] != rune('G') {
-						goto l812
+						goto l796
 					}
 					position++
 				}
-			l814:
+			l798:
 				{
-					position816, tokenIndex816 := position, tokenIndex
+					position800, tokenIndex800 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l817
+						goto l801
 					}
 					position++
-					goto l816
-				l817:
-					position, tokenIndex = position816, tokenIndex816
+					goto l800
+				l801:
+					position, tokenIndex = position800, tokenIndex800
 					if buffer[position] != rune('O') {
-						goto l812
+						goto l796
 					}
 					position++
 				}
-			l816:
+			l800:
 				{
-					position818, tokenIndex818 := position, tokenIndex
+					position802, tokenIndex802 := position, tokenIndex
 					if buffer[position] != rune('t') {
-						goto l819
+						goto l803
 					}
 					position++
-					goto l818
-				l819:
-					position, tokenIndex = position818, tokenIndex818
+					goto l802
+				l803:
+					position, tokenIndex = position802, tokenIndex802
 					if buffer[position] != rune('T') {
-						goto l812
+						goto l796
 					}
 					position++
 				}
-			l818:
+			l802:
 				if buffer[position] != rune('_') {
-					goto l812
+					goto l796
 				}
 				position++
 				{
-					position820, tokenIndex820 := position, tokenIndex
+					position804, tokenIndex804 := position, tokenIndex
 					if buffer[position] != rune('l') {
-						goto l821
+						goto l805
 					}
 					position++
-					goto l820
-				l821:
-					position, tokenIndex = position820, tokenIndex820
+					goto l804
+				l805:
+					position, tokenIndex = position804, tokenIndex804
 					if buffer[position] != rune('L') {
-						goto l812
+						goto l796
 					}
 					position++
 				}
-			l820:
+			l804:
 				{
-					position822, tokenIndex822 := position, tokenIndex
+					position806, tokenIndex806 := position, tokenIndex
 					if buffer[position] != rune('o') {
-						goto l823
+						goto l807
 					}
 					position++
-					goto l822
-				l823:
-					position, tokenIndex = position822, tokenIndex822
+					goto l806
+				l807:
+					position, tokenIndex = position806, tokenIndex806
 					if buffer[position] != rune('O') {
-						goto l812
+						goto l796
 					}
 					position++
 				}
-			l822:
+			l806:
 				if buffer[position] != rune('1') {
-					goto l812
+					goto l796
 				}
 				position++
 				if buffer[position] != rune('2') {
-					goto l812
+					goto l796
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l812
+					goto l796
 				}
 				position++
 				if !_rules[ruleSymbolName]() {
-					goto l812
+					goto l796
 				}
-				add(ruleARMGOTLow12, position813)
+				add(ruleARMGOTLow12, position797)
 			}
 			return true
-		l812:
-			position, tokenIndex = position812, tokenIndex812
+		l796:
+			position, tokenIndex = position796, tokenIndex796
 			return false
 		},
-		/* 48 ARMPostincrement <- <'!'> */
+		/* 50 ARMPostincrement <- <'!'> */
 		func() bool {
-			position824, tokenIndex824 := position, tokenIndex
+			position808, tokenIndex808 := position, tokenIndex
 			{
-				position825 := position
+				position809 := position
 				if buffer[position] != rune('!') {
-					goto l824
+					goto l808
 				}
 				position++
-				add(ruleARMPostincrement, position825)
+				add(ruleARMPostincrement, position809)
 			}
 			return true
-		l824:
-			position, tokenIndex = position824, tokenIndex824
+		l808:
+			position, tokenIndex = position808, tokenIndex808
 			return false
 		},
-		/* 49 BaseIndexScale <- <('(' RegisterOrConstant? WS? (',' WS? RegisterOrConstant WS? (',' [0-9]+)?)? ')')> */
+		/* 51 BaseIndexScale <- <('(' RegisterOrConstant? WS? (',' WS? RegisterOrConstant WS? (',' [0-9]+)?)? ')')> */
 		func() bool {
-			position826, tokenIndex826 := position, tokenIndex
+			position810, tokenIndex810 := position, tokenIndex
 			{
-				position827 := position
+				position811 := position
 				if buffer[position] != rune('(') {
-					goto l826
+					goto l810
 				}
 				position++
 				{
-					position828, tokenIndex828 := position, tokenIndex
+					position812, tokenIndex812 := position, tokenIndex
 					if !_rules[ruleRegisterOrConstant]() {
-						goto l828
+						goto l812
 					}
-					goto l829
-				l828:
-					position, tokenIndex = position828, tokenIndex828
+					goto l813
+				l812:
+					position, tokenIndex = position812, tokenIndex812
 				}
-			l829:
+			l813:
 				{
-					position830, tokenIndex830 := position, tokenIndex
+					position814, tokenIndex814 := position, tokenIndex
 					if !_rules[ruleWS]() {
-						goto l830
+						goto l814
 					}
-					goto l831
-				l830:
-					position, tokenIndex = position830, tokenIndex830
+					goto l815
+				l814:
+					position, tokenIndex = position814, tokenIndex814
 				}
-			l831:
+			l815:
 				{
-					position832, tokenIndex832 := position, tokenIndex
+					position816, tokenIndex816 := position, tokenIndex
 					if buffer[position] != rune(',') {
-						goto l832
+						goto l816
 					}
 					position++
 					{
-						position834, tokenIndex834 := position, tokenIndex
+						position818, tokenIndex818 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l834
+							goto l818
 						}
-						goto l835
-					l834:
-						position, tokenIndex = position834, tokenIndex834
+						goto l819
+					l818:
+						position, tokenIndex = position818, tokenIndex818
 					}
-				l835:
+				l819:
 					if !_rules[ruleRegisterOrConstant]() {
-						goto l832
+						goto l816
 					}
 					{
-						position836, tokenIndex836 := position, tokenIndex
+						position820, tokenIndex820 := position, tokenIndex
 						if !_rules[ruleWS]() {
-							goto l836
+							goto l820
 						}
-						goto l837
-					l836:
-						position, tokenIndex = position836, tokenIndex836
+						goto l821
+					l820:
+						position, tokenIndex = position820, tokenIndex820
 					}
-				l837:
+				l821:
 					{
-						position838, tokenIndex838 := position, tokenIndex
+						position822, tokenIndex822 := position, tokenIndex
 						if buffer[position] != rune(',') {
-							goto l838
+							goto l822
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l838
+							goto l822
 						}
 						position++
-					l840:
+					l824:
 						{
-							position841, tokenIndex841 := position, tokenIndex
+							position825, tokenIndex825 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l841
+								goto l825
 							}
 							position++
-							goto l840
-						l841:
-							position, tokenIndex = position841, tokenIndex841
+							goto l824
+						l825:
+							position, tokenIndex = position825, tokenIndex825
 						}
-						goto l839
-					l838:
-						position, tokenIndex = position838, tokenIndex838
+						goto l823
+					l822:
+						position, tokenIndex = position822, tokenIndex822
 					}
-				l839:
-					goto l833
-				l832:
-					position, tokenIndex = position832, tokenIndex832
+				l823:
+					goto l817
+				l816:
+					position, tokenIndex = position816, tokenIndex816
 				}
-			l833:
+			l817:
 				if buffer[position] != rune(')') {
-					goto l826
+					goto l810
 				}
 				position++
-				add(ruleBaseIndexScale, position827)
+				add(ruleBaseIndexScale, position811)
 			}
 			return true
-		l826:
-			position, tokenIndex = position826, tokenIndex826
+		l810:
+			position, tokenIndex = position810, tokenIndex810
 			return false
 		},
-		/* 50 Operator <- <('+' / '-')> */
+		/* 52 Operator <- <('+' / '-')> */
 		func() bool {
-			position842, tokenIndex842 := position, tokenIndex
+			position826, tokenIndex826 := position, tokenIndex
 			{
-				position843 := position
+				position827 := position
 				{
-					position844, tokenIndex844 := position, tokenIndex
+					position828, tokenIndex828 := position, tokenIndex
 					if buffer[position] != rune('+') {
-						goto l845
+						goto l829
 					}
 					position++
-					goto l844
-				l845:
-					position, tokenIndex = position844, tokenIndex844
+					goto l828
+				l829:
+					position, tokenIndex = position828, tokenIndex828
 					if buffer[position] != rune('-') {
-						goto l842
+						goto l826
 					}
 					position++
 				}
-			l844:
-				add(ruleOperator, position843)
+			l828:
+				add(ruleOperator, position827)
 			}
 			return true
-		l842:
-			position, tokenIndex = position842, tokenIndex842
+		l826:
+			position, tokenIndex = position826, tokenIndex826
 			return false
 		},
-		/* 51 OffsetOperator <- <('+' / '-' / '*')> */
+		/* 53 OffsetOperator <- <('+' / '-' / '*')> */
 		func() bool {
-			position846, tokenIndex846 := position, tokenIndex
+			position830, tokenIndex830 := position, tokenIndex
 			{
-				position847 := position
+				position831 := position
 				{
-					position848, tokenIndex848 := position, tokenIndex
+					position832, tokenIndex832 := position, tokenIndex
 					if buffer[position] != rune('+') {
-						goto l849
+						goto l833
 					}
 					position++
-					goto l848
-				l849:
-					position, tokenIndex = position848, tokenIndex848
+					goto l832
+				l833:
+					position, tokenIndex = position832, tokenIndex832
 					if buffer[position] != rune('-') {
-						goto l850
+						goto l834
 					}
 					position++
-					goto l848
-				l850:
-					position, tokenIndex = position848, tokenIndex848
+					goto l832
+				l834:
+					position, tokenIndex = position832, tokenIndex832
 					if buffer[position] != rune('*') {
-						goto l846
+						goto l830
 					}
 					position++
 				}
-			l848:
-				add(ruleOffsetOperator, position847)
+			l832:
+				add(ruleOffsetOperator, position831)
 			}
 			return true
-		l846:
-			position, tokenIndex = position846, tokenIndex846
+		l830:
+			position, tokenIndex = position830, tokenIndex830
 			return false
 		},
-		/* 52 Offset <- <('+'? '-'? (('0' ('b' / 'B') ('0' / '1')+) / ('0' ('x' / 'X') ([0-9] / [0-9] / ([a-f] / [A-F]))+) / ((([0-9]+ WS OffsetOperator [0-9]+) / ([0-9]+ (OffsetOperator '(' [0-9]+ OffsetOperator [0-9]+ ')')?) / ([0-9]+ (OffsetOperator [0-9]+ OffsetOperator [0-9]+)?) / ([0-9]+ (OffsetOperator [0-9]+)?) / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ ')' OffsetOperator [0-9]+ OffsetOperator [0-9]+) / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ ')' OffsetOperator [0-9]+ !'x') / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ ')') / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ WS? OffsetOperator WS? [0-9]+ ')')) !([a-z] / [A-Z]))))> */
+		/* 54 Offset <- <('+'? '-'? (('0' ('b' / 'B') ('0' / '1')+) / ('0' ('x' / 'X') ([0-9] / [0-9] / ([a-f] / [A-F]))+) / ((([0-9]+ WS OffsetOperator [0-9]+) / ([0-9]+ (OffsetOperator '(' [0-9]+ OffsetOperator [0-9]+ ')')?) / ([0-9]+ (OffsetOperator [0-9]+ OffsetOperator [0-9]+)?) / ([0-9]+ (OffsetOperator [0-9]+)?) / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ ')' OffsetOperator [0-9]+ OffsetOperator [0-9]+) / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ ')' OffsetOperator [0-9]+ !'x') / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ ')') / ('(' [0-9]+ WS? OffsetOperator WS? [0-9]+ WS? OffsetOperator WS? [0-9]+ ')')) !([a-z] / [A-Z]))))> */
 		func() bool {
-			position851, tokenIndex851 := position, tokenIndex
+			position835, tokenIndex835 := position, tokenIndex
 			{
-				position852 := position
+				position836 := position
 				{
-					position853, tokenIndex853 := position, tokenIndex
+					position837, tokenIndex837 := position, tokenIndex
 					if buffer[position] != rune('+') {
-						goto l853
+						goto l837
 					}
 					position++
-					goto l854
-				l853:
-					position, tokenIndex = position853, tokenIndex853
+					goto l838
+				l837:
+					position, tokenIndex = position837, tokenIndex837
 				}
-			l854:
+			l838:
 				{
-					position855, tokenIndex855 := position, tokenIndex
+					position839, tokenIndex839 := position, tokenIndex
 					if buffer[position] != rune('-') {
-						goto l855
+						goto l839
 					}
 					position++
-					goto l856
-				l855:
-					position, tokenIndex = position855, tokenIndex855
+					goto l840
+				l839:
+					position, tokenIndex = position839, tokenIndex839
 				}
-			l856:
+			l840:
 				{
-					position857, tokenIndex857 := position, tokenIndex
+					position841, tokenIndex841 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l858
+						goto l842
 					}
 					position++
 					{
-						position859, tokenIndex859 := position, tokenIndex
+						position843, tokenIndex843 := position, tokenIndex
 						if buffer[position] != rune('b') {
-							goto l860
+							goto l844
 						}
 						position++
-						goto l859
-					l860:
-						position, tokenIndex = position859, tokenIndex859
+						goto l843
+					l844:
+						position, tokenIndex = position843, tokenIndex843
 						if buffer[position] != rune('B') {
-							goto l858
+							goto l842
 						}
 						position++
 					}
-				l859:
+				l843:
 					{
-						position863, tokenIndex863 := position, tokenIndex
+						position847, tokenIndex847 := position, tokenIndex
 						if buffer[position] != rune('0') {
-							goto l864
+							goto l848
 						}
 						position++
-						goto l863
-					l864:
-						position, tokenIndex = position863, tokenIndex863
+						goto l847
+					l848:
+						position, tokenIndex = position847, tokenIndex847
 						if buffer[position] != rune('1') {
-							goto l858
+							goto l842
 						}
 						position++
 					}
-				l863:
-				l861:
+				l847:
+				l845:
 					{
-						position862, tokenIndex862 := position, tokenIndex
+						position846, tokenIndex846 := position, tokenIndex
 						{
-							position865, tokenIndex865 := position, tokenIndex
+							position849, tokenIndex849 := position, tokenIndex
 							if buffer[position] != rune('0') {
-								goto l866
+								goto l850
 							}
 							position++
-							goto l865
-						l866:
-							position, tokenIndex = position865, tokenIndex865
+							goto l849
+						l850:
+							position, tokenIndex = position849, tokenIndex849
 							if buffer[position] != rune('1') {
-								goto l862
+								goto l846
 							}
 							position++
 						}
-					l865:
-						goto l861
-					l862:
-						position, tokenIndex = position862, tokenIndex862
+					l849:
+						goto l845
+					l846:
+						position, tokenIndex = position846, tokenIndex846
 					}
-					goto l857
-				l858:
-					position, tokenIndex = position857, tokenIndex857
+					goto l841
+				l842:
+					position, tokenIndex = position841, tokenIndex841
 					if buffer[position] != rune('0') {
-						goto l867
+						goto l851
 					}
 					position++
 					{
-						position868, tokenIndex868 := position, tokenIndex
+						position852, tokenIndex852 := position, tokenIndex
 						if buffer[position] != rune('x') {
-							goto l869
+							goto l853
 						}
 						position++
-						goto l868
-					l869:
-						position, tokenIndex = position868, tokenIndex868
+						goto l852
+					l853:
+						position, tokenIndex = position852, tokenIndex852
 						if buffer[position] != rune('X') {
-							goto l867
+							goto l851
 						}
 						position++
 					}
-				l868:
+				l852:
 					{
-						position872, tokenIndex872 := position, tokenIndex
+						position856, tokenIndex856 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l873
+							goto l857
 						}
 						position++
-						goto l872
-					l873:
-						position, tokenIndex = position872, tokenIndex872
+						goto l856
+					l857:
+						position, tokenIndex = position856, tokenIndex856
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l874
+							goto l858
 						}
 						position++
-						goto l872
-					l874:
-						position, tokenIndex = position872, tokenIndex872
+						goto l856
+					l858:
+						position, tokenIndex = position856, tokenIndex856
 						{
-							position875, tokenIndex875 := position, tokenIndex
+							position859, tokenIndex859 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('f') {
-								goto l876
+								goto l860
 							}
 							position++
-							goto l875
-						l876:
-							position, tokenIndex = position875, tokenIndex875
+							goto l859
+						l860:
+							position, tokenIndex = position859, tokenIndex859
 							if c := buffer[position]; c < rune('A') || c > rune('F') {
-								goto l867
+								goto l851
 							}
 							position++
 						}
-					l875:
+					l859:
 					}
-				l872:
-				l870:
+				l856:
+				l854:
 					{
-						position871, tokenIndex871 := position, tokenIndex
+						position855, tokenIndex855 := position, tokenIndex
 						{
-							position877, tokenIndex877 := position, tokenIndex
+							position861, tokenIndex861 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l878
+								goto l862
 							}
 							position++
-							goto l877
-						l878:
-							position, tokenIndex = position877, tokenIndex877
+							goto l861
+						l862:
+							position, tokenIndex = position861, tokenIndex861
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l879
+								goto l863
 							}
 							position++
-							goto l877
-						l879:
-							position, tokenIndex = position877, tokenIndex877
+							goto l861
+						l863:
+							position, tokenIndex = position861, tokenIndex861
 							{
-								position880, tokenIndex880 := position, tokenIndex
+								position864, tokenIndex864 := position, tokenIndex
 								if c := buffer[position]; c < rune('a') || c > rune('f') {
-									goto l881
+									goto l865
 								}
 								position++
-								goto l880
-							l881:
-								position, tokenIndex = position880, tokenIndex880
+								goto l864
+							l865:
+								position, tokenIndex = position864, tokenIndex864
 								if c := buffer[position]; c < rune('A') || c > rune('F') {
-									goto l871
+									goto l855
 								}
 								position++
 							}
-						l880:
+						l864:
 						}
-					l877:
-						goto l870
-					l871:
-						position, tokenIndex = position871, tokenIndex871
+					l861:
+						goto l854
+					l855:
+						position, tokenIndex = position855, tokenIndex855
 					}
-					goto l857
-				l867:
-					position, tokenIndex = position857, tokenIndex857
+					goto l841
+				l851:
+					position, tokenIndex = position841, tokenIndex841
 					{
-						position882, tokenIndex882 := position, tokenIndex
+						position866, tokenIndex866 := position, tokenIndex
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l883
+							goto l867
 						}
 						position++
-					l884:
+					l868:
 						{
-							position885, tokenIndex885 := position, tokenIndex
+							position869, tokenIndex869 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l885
+								goto l869
 							}
 							position++
-							goto l884
-						l885:
-							position, tokenIndex = position885, tokenIndex885
+							goto l868
+						l869:
+							position, tokenIndex = position869, tokenIndex869
 						}
 						if !_rules[ruleWS]() {
-							goto l883
+							goto l867
 						}
 						if !_rules[ruleOffsetOperator]() {
-							goto l883
+							goto l867
 						}
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l883
+							goto l867
 						}
 						position++
-					l886:
+					l870:
 						{
-							position887, tokenIndex887 := position, tokenIndex
+							position871, tokenIndex871 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l887
+								goto l871
 							}
 							position++
-							goto l886
-						l887:
-							position, tokenIndex = position887, tokenIndex887
+							goto l870
+						l871:
+							position, tokenIndex = position871, tokenIndex871
 						}
-						goto l882
-					l883:
-						position, tokenIndex = position882, tokenIndex882
+						goto l866
+					l867:
+						position, tokenIndex = position866, tokenIndex866
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l888
+							goto l872
 						}
 						position++
-					l889:
+					l873:
 						{
-							position890, tokenIndex890 := position, tokenIndex
+							position874, tokenIndex874 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l890
+								goto l874
 							}
 							position++
-							goto l889
-						l890:
-							position, tokenIndex = position890, tokenIndex890
+							goto l873
+						l874:
+							position, tokenIndex = position874, tokenIndex874
 						}
 						{
-							position891, tokenIndex891 := position, tokenIndex
+							position875, tokenIndex875 := position, tokenIndex
 							if !_rules[ruleOffsetOperator]() {
-								goto l891
+								goto l875
 							}
 							if buffer[position] != rune('(') {
-								goto l891
+								goto l875
 							}
 							position++
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l891
+								goto l875
 							}
 							position++
-						l893:
+						l877:
 							{
-								position894, tokenIndex894 := position, tokenIndex
+								position878, tokenIndex878 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l894
+									goto l878
 								}
 								position++
-								goto l893
-							l894:
-								position, tokenIndex = position894, tokenIndex894
+								goto l877
+							l878:
+								position, tokenIndex = position878, tokenIndex878
 							}
 							if !_rules[ruleOffsetOperator]() {
-								goto l891
+								goto l875
 							}
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l891
+								goto l875
 							}
 							position++
-						l895:
+						l879:
 							{
-								position896, tokenIndex896 := position, tokenIndex
+								position880, tokenIndex880 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l896
+									goto l880
 								}
 								position++
-								goto l895
-							l896:
-								position, tokenIndex = position896, tokenIndex896
+								goto l879
+							l880:
+								position, tokenIndex = position880, tokenIndex880
 							}
 							if buffer[position] != rune(')') {
-								goto l891
+								goto l875
 							}
 							position++
-							goto l892
-						l891:
-							position, tokenIndex = position891, tokenIndex891
-						}
-					l892:
-						goto l882
-					l888:
-						position, tokenIndex = position882, tokenIndex882
+							goto l876
+						l875:
+							position, tokenIndex = position875, tokenIndex875
+						}
+					l876:
+						goto l866
+					l872:
+						position, tokenIndex = position866, tokenIndex866
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l897
+							goto l881
 						}
 						position++
-					l898:
+					l882:
 						{
-							position899, tokenIndex899 := position, tokenIndex
+							position883, tokenIndex883 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l899
+								goto l883
 							}
 							position++
-							goto l898
-						l899:
-							position, tokenIndex = position899, tokenIndex899
+							goto l882
+						l883:
+							position, tokenIndex = position883, tokenIndex883
 						}
 						{
-							position900, tokenIndex900 := position, tokenIndex
+							position884, tokenIndex884 := position, tokenIndex
 							if !_rules[ruleOffsetOperator]() {
-								goto l900
+								goto l884
 							}
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l900
+								goto l884
 							}
 							position++
-						l902:
+						l886:
 							{
-								position903, tokenIndex903 := position, tokenIndex
+								position887, tokenIndex887 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l903
+									goto l887
 								}
 								position++
-								goto l902
-							l903:
-								position, tokenIndex = position903, tokenIndex903
+								goto l886
+							l887:
+								position, tokenIndex = position887, tokenIndex887
 							}
 							if !_rules[ruleOffsetOperator]() {
-								goto l900
+								goto l884
 							}
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l900
+								goto l884
 							}
 							position++
-						l904:
+						l888:
 							{
-								position905, tokenIndex905 := position, tokenIndex
+								position889, tokenIndex889 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l905
+									goto l889
 								}
 								position++
-								goto l904
-							l905:
-								position, tokenIndex = position905, tokenIndex905
+								goto l888
+							l889:
+								position, tokenIndex = position889, tokenIndex889
 							}
-							goto l901
-						l900:
-							position, tokenIndex = position900, tokenIndex900
-						}
-					l901:
-						goto l882
-					l897:
-						position, tokenIndex = position882, tokenIndex882
+							goto l885
+						l884:
+							position, tokenIndex = position884, tokenIndex884
+						}
+					l885:
+						goto l866
+					l881:
+						position, tokenIndex = position866, tokenIndex866
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l906
+							goto l890
 						}
 						position++
-					l907:
+					l891:
 						{
-							position908, tokenIndex908 := position, tokenIndex
+							position892, tokenIndex892 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l908
+								goto l892
 							}
 							position++
-							goto l907
-						l908:
-							position, tokenIndex = position908, tokenIndex908
+							goto l891
+						l892:
+							position, tokenIndex = position892, tokenIndex892
 						}
 						{
-							position909, tokenIndex909 := position, tokenIndex
+							position893, tokenIndex893 := position, tokenIndex
 							if !_rules[ruleOffsetOperator]() {
-								goto l909
+								goto l893
 							}
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l909
+								goto l893
 							}
 							position++
-						l911:
+						l895:
 							{
-								position912, tokenIndex912 := position, tokenIndex
+								position896, tokenIndex896 := position, tokenIndex
 								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l912
+									goto l896
 								}
 								position++
-								goto l911
-							l912:
-								position, tokenIndex = position912, tokenIndex912
+								goto l895
+							l896:
+								position, tokenIndex = position896, tokenIndex896
 							}
-							goto l910
-						l909:
-							position, tokenIndex = position909, tokenIndex909
+							goto l894
+						l893:
+							position, tokenIndex = position893, tokenIndex893
 						}
-					l910:
-						goto l882
-					l906:
-						position, tokenIndex = position882, tokenIndex882
+					l894:
+						goto l866
+					l890:
+						position, tokenIndex = position866, tokenIndex866
 						if buffer[position] != rune('(') {
-							goto l913
+							goto l897
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l913
+							goto l897
 						}
 						position++
-					l914:
+					l898:
 						{
-							position915, tokenIndex915 := position, tokenIndex
+							position899, tokenIndex899 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l915
+								goto l899
 							}
 							position++
-							goto l914
-						l915:
-							position, tokenIndex = position915, tokenIndex915
+							goto l898
+						l899:
+							position, tokenIndex = position899, tokenIndex899
 						}
 						{
-							position916, tokenIndex916 := position, tokenIndex
+							position900, tokenIndex900 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l916
+								goto l900
 							}
-							goto l917
-						l916:
-							position, tokenIndex = position916, tokenIndex916
+							goto l901
+						l900:
+							position, tokenIndex = position900, tokenIndex900
 						}
-					l917:
+					l901:
 						if !_rules[ruleOffsetOperator]() {
-							goto l913
+							goto l897
 						}
 						{
-							position918, tokenIndex918 := position, tokenIndex
+							position902, tokenIndex902 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l918
+								goto l902
 							}
-							goto l919
-						l918:
-							position, tokenIndex = position918, tokenIndex918
+							goto l903
+						l902:
+							position, tokenIndex = position902, tokenIndex902
 						}
-					l919:
+					l903:
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l913
+							goto l897
 						}
 						position++
-					l920:
+					l904:
 						{
-							position921, tokenIndex921 := position, tokenIndex
+							position905, tokenIndex905 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l921
+								goto l905
 							}
 							position++
-							goto l920
-						l921:
-							position, tokenIndex = position921, tokenIndex921
+							goto l904
+						l905:
+							position, tokenIndex = position905, tokenIndex905
 						}
 						if buffer[position] != rune(')') {
-							goto l913
+							goto l897
 						}
 						position++
 						if !_rules[ruleOffsetOperator]() {
-							goto l913
+							goto l897
 						}
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l913
+							goto l897
 						}
 						position++
-					l922:
+					l906:
 						{
-							position923, tokenIndex923 := position, tokenIndex
+							position907, tokenIndex907 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l923
+								goto l907
 							}
 							position++
-							goto l922
-						l923:
-							position, tokenIndex = position923, tokenIndex923
+							goto l906
+						l907:
+							position, tokenIndex = position907, tokenIndex907
 						}
 						if !_rules[ruleOffsetOperator]() {
-							goto l913
+							goto l897
 						}
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l913
+							goto l897
 						}
 						position++
-					l924:
+					l908:
 						{
-							position925, tokenIndex925 := position, tokenIndex
+							position909, tokenIndex909 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l925
+								goto l909
 							}
 							position++
-							goto l924
-						l925:
-							position, tokenIndex = position925, tokenIndex925
+							goto l908
+						l909:
+							position, tokenIndex = position909, tokenIndex909
 						}
-						goto l882
-					l913:
-						position, tokenIndex = position882, tokenIndex882
+						goto l866
+					l897:
+						position, tokenIndex = position866, tokenIndex866
 						if buffer[position] != rune('(') {
-							goto l926
+							goto l910
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l926
+							goto l910
 						}
 						position++
-					l927:
+					l911:
 						{
-							position928, tokenIndex928 := position, tokenIndex
+							position912, tokenIndex912 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l928
+								goto l912
 							}
 							position++
-							goto l927
-						l928:
-							position, tokenIndex = position928, tokenIndex928
+							goto l911
+						l912:
+							position, tokenIndex = position912, tokenIndex912
 						}
 						{
-							position929, tokenIndex929 := position, tokenIndex
+							position913, tokenIndex913 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l929
+								goto l913
 							}
-							goto l930
-						l929:
-							position, tokenIndex = position929, tokenIndex929
+							goto l914
+						l913:
+							position, tokenIndex = position913, tokenIndex913
 						}
-					l930:
+					l914:
 						if !_rules[ruleOffsetOperator]() {
-							goto l926
+							goto l910
 						}
 						{
-							position931, tokenIndex931 := position, tokenIndex
+							position915, tokenIndex915 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l931
+								goto l915
 							}
-							goto l932
-						l931:
-							position, tokenIndex = position931, tokenIndex931
+							goto l916
+						l915:
+							position, tokenIndex = position915, tokenIndex915
 						}
-					l932:
+					l916:
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l926
+							goto l910
 						}
 						position++
-					l933:
+					l917:
 						{
-							position934, tokenIndex934 := position, tokenIndex
+							position918, tokenIndex918 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l934
+								goto l918
 							}
 							position++
-							goto l933
-						l934:
-							position, tokenIndex = position934, tokenIndex934
+							goto l917
+						l918:
+							position, tokenIndex = position918, tokenIndex918
 						}
 						if buffer[position] != rune(')') {
-							goto l926
+							goto l910
 						}
 						position++
 						if !_rules[ruleOffsetOperator]() {
-							goto l926
+							goto l910
 						}
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l926
+							goto l910
 						}
 						position++
-					l935:
+					l919:
 						{
-							position936, tokenIndex936 := position, tokenIndex
+							position920, tokenIndex920 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l936
+								goto l920
 							}
 							position++
-							goto l935
-						l936:
-							position, tokenIndex = position936, tokenIndex936
+							goto l919
+						l920:
+							position, tokenIndex = position920, tokenIndex920
 						}
 						{
-							position937, tokenIndex937 := position, tokenIndex
+							position921, tokenIndex921 := position, tokenIndex
 							if buffer[position] != rune('x') {
-								goto l937
+								goto l921
 							}
 							position++
-							goto l926
-						l937:
-							position, tokenIndex = position937, tokenIndex937
+							goto l910
+						l921:
+							position, tokenIndex = position921, tokenIndex921
 						}
-						goto l882
-					l926:
-						position, tokenIndex = position882, tokenIndex882
+						goto l866
+					l910:
+						position, tokenIndex = position866, tokenIndex866
 						if buffer[position] != rune('(') {
-							goto l938
+							goto l922
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l938
+							goto l922
 						}
 						position++
-					l939:
+					l923:
 						{
-							position940, tokenIndex940 := position, tokenIndex
+							position924, tokenIndex924 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l940
+								goto l924
 							}
 							position++
-							goto l939
-						l940:
-							position, tokenIndex = position940, tokenIndex940
+							goto l923
+						l924:
+							position, tokenIndex = position924, tokenIndex924
 						}
 						{
-							position941, tokenIndex941 := position, tokenIndex
+							position925, tokenIndex925 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l941
+								goto l925
 							}
-							goto l942
-						l941:
-							position, tokenIndex = position941, tokenIndex941
+							goto l926
+						l925:
+							position, tokenIndex = position925, tokenIndex925
 						}
-					l942:
+					l926:
 						if !_rules[ruleOffsetOperator]() {
-							goto l938
+							goto l922
 						}
 						{
-							position943, tokenIndex943 := position, tokenIndex
+							position927, tokenIndex927 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l943
+								goto l927
 							}
-							goto l944
-						l943:
-							position, tokenIndex = position943, tokenIndex943
+							goto l928
+						l927:
+							position, tokenIndex = position927, tokenIndex927
 						}
-					l944:
+					l928:
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l938
+							goto l922
 						}
 						position++
-					l945:
+					l929:
 						{
-							position946, tokenIndex946 := position, tokenIndex
+							position930, tokenIndex930 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l946
+								goto l930
 							}
 							position++
-							goto l945
-						l946:
-							position, tokenIndex = position946, tokenIndex946
+							goto l929
+						l930:
+							position, tokenIndex = position930, tokenIndex930
 						}
 						if buffer[position] != rune(')') {
-							goto l938
+							goto l922
 						}
 						position++
-						goto l882
-					l938:
-						position, tokenIndex = position882, tokenIndex882
+						goto l866
+					l922:
+						position, tokenIndex = position866, tokenIndex866
 						if buffer[position] != rune('(') {
-							goto l851
+							goto l835
 						}
 						position++
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l851
+							goto l835
 						}
 						position++
-					l947:
+					l931:
 						{
-							position948, tokenIndex948 := position, tokenIndex
+							position932, tokenIndex932 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l948
+								goto l932
 							}
 							position++
-							goto l947
-						l948:
-							position, tokenIndex = position948, tokenIndex948
+							goto l931
+						l932:
+							position, tokenIndex = position932, tokenIndex932
 						}
 						{
-							position949, tokenIndex949 := position, tokenIndex
+							position933, tokenIndex933 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l949
+								goto l933
 							}
-							goto l950
-						l949:
-							position, tokenIndex = position949, tokenIndex949
+							goto l934
+						l933:
+							position, tokenIndex = position933, tokenIndex933
 						}
-					l950:
+					l934:
 						if !_rules[ruleOffsetOperator]() {
-							goto l851
+							goto l835
 						}
 						{
-							position951, tokenIndex951 := position, tokenIndex
+							position935, tokenIndex935 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l951
+								goto l935
 							}
-							goto l952
-						l951:
-							position, tokenIndex = position951, tokenIndex951
+							goto l936
+						l935:
+							position, tokenIndex = position935, tokenIndex935
 						}
-					l952:
+					l936:
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l851
+							goto l835
 						}
 						position++
-					l953:
+					l937:
 						{
-							position954, tokenIndex954 := position, tokenIndex
+							position938, tokenIndex938 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l954
+								goto l938
 							}
 							position++
-							goto l953
-						l954:
-							position, tokenIndex = position954, tokenIndex954
+							goto l937
+						l938:
+							position, tokenIndex = position938, tokenIndex938
 						}
 						{
-							position955, tokenIndex955 := position, tokenIndex
+							position939, tokenIndex939 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l955
+								goto l939
 							}
-							goto l956
-						l955:
-							position, tokenIndex = position955, tokenIndex955
+							goto l940
+						l939:
+							position, tokenIndex = position939, tokenIndex939
 						}
-					l956:
+					l940:
 						if !_rules[ruleOffsetOperator]() {
-							goto l851
+							goto l835
 						}
 						{
-							position957, tokenIndex957 := position, tokenIndex
+							position941, tokenIndex941 := position, tokenIndex
 							if !_rules[ruleWS]() {
-								goto l957
+								goto l941
 							}
-							goto l958
-						l957:
-							position, tokenIndex = position957, tokenIndex957
+							goto l942
+						l941:
+							position, tokenIndex = position941, tokenIndex941
 						}
-					l958:
+					l942:
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l851
+							goto l835
 						}
 						position++
-					l959:
+					l943:
 						{
-							position960, tokenIndex960 := position, tokenIndex
+							position944, tokenIndex944 := position, tokenIndex
 							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l960
+								goto l944
 							}
 							position++
-							goto l959
-						l960:
-							position, tokenIndex = position960, tokenIndex960
+							goto l943
+						l944:
+							position, tokenIndex = position944, tokenIndex944
 						}
 						if buffer[position] != rune(')') {
-							goto l851
+							goto l835
 						}
 						position++
 					}
-				l882:
+				l866:
 					{
-						position961, tokenIndex961 := position, tokenIndex
+						position945, tokenIndex945 := position, tokenIndex
 						{
-							position962, tokenIndex962 := position, tokenIndex
+							position946, tokenIndex946 := position, tokenIndex
 							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l963
+								goto l947
 							}
 							position++
-							goto l962
-						l963:
-							position, tokenIndex = position962, tokenIndex962
+							goto l946
+						l947:
+							position, tokenIndex = position946, tokenIndex946
 							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l961
+								goto l945
 							}
 							position++
 						}
-					l962:
-						goto l851
-					l961:
-						position, tokenIndex = position961, tokenIndex961
+					l946:
+						goto l835
+					l945:
+						position, tokenIndex = position945, tokenIndex945
 					}
 				}
-			l857:
-				add(ruleOffset, position852)
+			l841:
+				add(ruleOffset, position836)
 			}
 			return true
-		l851:
-			position, tokenIndex = position851, tokenIndex851
+		l835:
+			position, tokenIndex = position835, tokenIndex835
 			return false
 		},
-		/* 53 Section <- <([a-z] / [A-Z] / '@')+> */
+		/* 55 Section <- <([a-z] / [A-Z] / '@')+> */
 		func() bool {
-			position964, tokenIndex964 := position, tokenIndex
+			position948, tokenIndex948 := position, tokenIndex
 			{
-				position965 := position
+				position949 := position
 				{
-					position968, tokenIndex968 := position, tokenIndex
+					position952, tokenIndex952 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l969
+						goto l953
 					}
 					position++
-					goto l968
-				l969:
-					position, tokenIndex = position968, tokenIndex968
+					goto l952
+				l953:
+					position, tokenIndex = position952, tokenIndex952
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l970
+						goto l954
 					}
 					position++
-					goto l968
-				l970:
-					position, tokenIndex = position968, tokenIndex968
+					goto l952
+				l954:
+					position, tokenIndex = position952, tokenIndex952
 					if buffer[position] != rune('@') {
-						goto l964
+						goto l948
 					}
 					position++
 				}
-			l968:
-			l966:
+			l952:
+			l950:
 				{
-					position967, tokenIndex967 := position, tokenIndex
+					position951, tokenIndex951 := position, tokenIndex
 					{
-						position971, tokenIndex971 := position, tokenIndex
+						position955, tokenIndex955 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l972
+							goto l956
 						}
 						position++
-						goto l971
-					l972:
-						position, tokenIndex = position971, tokenIndex971
+						goto l955
+					l956:
+						position, tokenIndex = position955, tokenIndex955
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l973
+							goto l957
 						}
 						position++
-						goto l971
-					l973:
-						position, tokenIndex = position971, tokenIndex971
+						goto l955
+					l957:
+						position, tokenIndex = position955, tokenIndex955
 						if buffer[position] != rune('@') {
-							goto l967
+							goto l951
 						}
 						position++
 					}
-				l971:
-					goto l966
-				l967:
-					position, tokenIndex = position967, tokenIndex967
+				l955:
+					goto l950
+				l951:
+					position, tokenIndex = position951, tokenIndex951
 				}
-				add(ruleSection, position965)
+				add(ruleSection, position949)
 			}
 			return true
-		l964:
-			position, tokenIndex = position964, tokenIndex964
+		l948:
+			position, tokenIndex = position948, tokenIndex948
 			return false
 		},
-		/* 54 SegmentRegister <- <('%' ([c-g] / 's') ('s' ':'))> */
+		/* 56 SegmentRegister <- <('%' ([c-g] / 's') ('s' ':'))> */
 		func() bool {
-			position974, tokenIndex974 := position, tokenIndex
+			position958, tokenIndex958 := position, tokenIndex
 			{
-				position975 := position
+				position959 := position
 				if buffer[position] != rune('%') {
-					goto l974
+					goto l958
 				}
 				position++
 				{
-					position976, tokenIndex976 := position, tokenIndex
+					position960, tokenIndex960 := position, tokenIndex
 					if c := buffer[position]; c < rune('c') || c > rune('g') {
-						goto l977
+						goto l961
 					}
 					position++
-					goto l976
-				l977:
-					position, tokenIndex = position976, tokenIndex976
+					goto l960
+				l961:
+					position, tokenIndex = position960, tokenIndex960
 					if buffer[position] != rune('s') {
-						goto l974
+						goto l958
 					}
 					position++
 				}
-			l976:
+			l960:
 				if buffer[position] != rune('s') {
-					goto l974
+					goto l958
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l974
+					goto l958
 				}
 				position++
-				add(ruleSegmentRegister, position975)
+				add(ruleSegmentRegister, position959)
 			}
 			return true
-		l974:
-			position, tokenIndex = position974, tokenIndex974
+		l958:
+			position, tokenIndex = position958, tokenIndex958
 			return false
 		},
 	}
diff --git a/util/fipstools/delocate/testdata/aarch64-Basic/out.s b/util/fipstools/delocate/testdata/aarch64-Basic/out.s
index 86bff80f08..c947525e18 100644
--- a/util/fipstools/delocate/testdata/aarch64-Basic/out.s
+++ b/util/fipstools/delocate/testdata/aarch64-Basic/out.s
@@ -180,6 +180,7 @@ BORINGSSL_bcm_text_end:
 .type .Lbcm_redirector_remote_function, @function
 .Lbcm_redirector_remote_function:
 .cfi_startproc
+	hint #34 // bti c
 	b remote_function
 .cfi_endproc
 .size .Lbcm_redirector_remote_function, .-.Lbcm_redirector_remote_function
@@ -188,6 +189,7 @@ BORINGSSL_bcm_text_end:
 .type .Lbcm_redirector_y0, @function
 .Lbcm_redirector_y0:
 .cfi_startproc
+	hint #34 // bti c
 	b y0
 .cfi_endproc
 .size .Lbcm_redirector_y0, .-.Lbcm_redirector_y0
@@ -196,6 +198,7 @@ BORINGSSL_bcm_text_end:
 .type .Lbcm_redirector_y12, @function
 .Lbcm_redirector_y12:
 .cfi_startproc
+	hint #34 // bti c
 	b y12
 .cfi_endproc
 .size .Lbcm_redirector_y12, .-.Lbcm_redirector_y12
@@ -204,6 +207,7 @@ BORINGSSL_bcm_text_end:
 .type bss_symbol_bss_get, @function
 bss_symbol_bss_get:
 .cfi_startproc
+	hint #34 // bti c
 	adrp x0, .Lbss_symbol_local_target
 	add x0, x0, :lo12:.Lbss_symbol_local_target
 	ret
@@ -214,6 +218,7 @@ bss_symbol_bss_get:
 .type .Lboringssl_loadgot_BORINGSSL_bcm_text_end, @function
 .Lboringssl_loadgot_BORINGSSL_bcm_text_end:
 .cfi_startproc
+	hint #34 // bti c
 	adrp x0, :got:BORINGSSL_bcm_text_end
 	ldr x0, [x0, :got_lo12:BORINGSSL_bcm_text_end]
 	ret
@@ -224,6 +229,7 @@ bss_symbol_bss_get:
 .type .Lboringssl_loadgot_BORINGSSL_bcm_text_start, @function
 .Lboringssl_loadgot_BORINGSSL_bcm_text_start:
 .cfi_startproc
+	hint #34 // bti c
 	adrp x0, :got:BORINGSSL_bcm_text_start
 	ldr x0, [x0, :got_lo12:BORINGSSL_bcm_text_start]
 	ret
@@ -234,6 +240,7 @@ bss_symbol_bss_get:
 .type .Lboringssl_loadgot_stderr, @function
 .Lboringssl_loadgot_stderr:
 .cfi_startproc
+	hint #34 // bti c
 	adrp x0, :got:stderr
 	ldr x0, [x0, :got_lo12:stderr]
 	ret
@@ -244,6 +251,7 @@ bss_symbol_bss_get:
 .type .LOPENSSL_armcap_P_addr, @function
 .LOPENSSL_armcap_P_addr:
 .cfi_startproc
+	hint #34 // bti c
 	adrp x0, OPENSSL_armcap_P
 	add x0, x0, :lo12:OPENSSL_armcap_P
 	ret
diff --git a/util/fipstools/delocate/testdata/x86_64-LabelRewrite/out.s b/util/fipstools/delocate/testdata/x86_64-LabelRewrite/out.s
index 7a11e91433..10e40481b7 100644
--- a/util/fipstools/delocate/testdata/x86_64-LabelRewrite/out.s
+++ b/util/fipstools/delocate/testdata/x86_64-LabelRewrite/out.s
@@ -93,7 +93,7 @@ bar:
 # assumption that it's too small to hold a pointer. But Clang
 # will store offsets in it.
 # WAS .byte   (.LBB231_40-.LBB231_19)>>2, 4, .Lfoo, (.Lfoo), .Lfoo<<400, (   .Lfoo ) <<  66
-	.byte	(.LBB231_40_BCM_1-.LBB231_19_BCM_1)>>2, 4, .Lfoo_BCM_1, (.Lfoo_BCM_1), .Lfoo_BCM_1<<400, (   .Lfoo_BCM_1 ) <<  66
+	.byte	(.LBB231_40_BCM_1-.LBB231_19_BCM_1)>>2, 4, .Lfoo_BCM_1, (.Lfoo_BCM_1), .Lfoo_BCM_1<<400, (.Lfoo_BCM_1)<<66
 .byte   421
 .text
 .loc 1 2 0