peg.peg.go

// Code generated by peg -inline -switch peg.peg. DO NOT EDIT.

// PE Grammar for PE Grammars
//
// Adapted from [1] by Ian Piumarta <first-name at last-name point com>.
//
// Best viewed using 140 columns monospaced with tabs every 8.
//
// [1] Bryan Ford.  "Parsing Expression Grammars: A Recognition-Based Syntactic
//     Foundation."  Symposium on Principles of Programming Languages,
//     January 14--16, 2004, Venice, Italy.

package main

import (
	"bytes"
	"fmt"
	"github.com/pointlander/peg/tree"
	"io"
	"os"
	"slices"
	"strconv"
)

const endSymbol rune = 1114112

/* The rule types inferred from the grammar are below. */
type pegRule uint8

const (
	ruleUnknown pegRule = iota
	ruleGrammar
	ruleImport
	ruleSingleImport
	ruleMultiImport
	ruleImportName
	ruleDefinition
	ruleExpression
	ruleSequence
	rulePrefix
	ruleSuffix
	rulePrimary
	ruleIdentifier
	ruleIdentStart
	ruleIdentCont
	ruleLiteral
	ruleClass
	ruleRanges
	ruleDoubleRanges
	ruleRange
	ruleDoubleRange
	ruleChar
	ruleDoubleChar
	ruleEscape
	ruleLeftArrow
	ruleSlash
	ruleAnd
	ruleNot
	ruleQuestion
	ruleStar
	rulePlus
	ruleOpen
	ruleClose
	ruleDot
	ruleSpaceComment
	ruleSpacing
	ruleMustSpacing
	ruleComment
	ruleSpace
	ruleHeader
	ruleHeaderSpaceComment
	ruleHeaderComment
	ruleEndOfLine
	ruleEndOfFile
	ruleAction
	ruleActionBody
	ruleBegin
	ruleEnd
	ruleAction0
	ruleAction1
	ruleAction2
	ruleAction3
	rulePegText
	ruleAction4
	ruleAction5
	ruleAction6
	ruleAction7
	ruleAction8
	ruleAction9
	ruleAction10
	ruleAction11
	ruleAction12
	ruleAction13
	ruleAction14
	ruleAction15
	ruleAction16
	ruleAction17
	ruleAction18
	ruleAction19
	ruleAction20
	ruleAction21
	ruleAction22
	ruleAction23
	ruleAction24
	ruleAction25
	ruleAction26
	ruleAction27
	ruleAction28
	ruleAction29
	ruleAction30
	ruleAction31
	ruleAction32
	ruleAction33
	ruleAction34
	ruleAction35
	ruleAction36
	ruleAction37
	ruleAction38
	ruleAction39
	ruleAction40
	ruleAction41
	ruleAction42
	ruleAction43
	ruleAction44
	ruleAction45
	ruleAction46
	ruleAction47
	ruleAction48
	ruleAction49
	ruleAction50
	ruleAction51
)

var rul3s = [...]string{
	"Unknown",
	"Grammar",
	"Import",
	"SingleImport",
	"MultiImport",
	"ImportName",
	"Definition",
	"Expression",
	"Sequence",
	"Prefix",
	"Suffix",
	"Primary",
	"Identifier",
	"IdentStart",
	"IdentCont",
	"Literal",
	"Class",
	"Ranges",
	"DoubleRanges",
	"Range",
	"DoubleRange",
	"Char",
	"DoubleChar",
	"Escape",
	"LeftArrow",
	"Slash",
	"And",
	"Not",
	"Question",
	"Star",
	"Plus",
	"Open",
	"Close",
	"Dot",
	"SpaceComment",
	"Spacing",
	"MustSpacing",
	"Comment",
	"Space",
	"Header",
	"HeaderSpaceComment",
	"HeaderComment",
	"EndOfLine",
	"EndOfFile",
	"Action",
	"ActionBody",
	"Begin",
	"End",
	"Action0",
	"Action1",
	"Action2",
	"Action3",
	"PegText",
	"Action4",
	"Action5",
	"Action6",
	"Action7",
	"Action8",
	"Action9",
	"Action10",
	"Action11",
	"Action12",
	"Action13",
	"Action14",
	"Action15",
	"Action16",
	"Action17",
	"Action18",
	"Action19",
	"Action20",
	"Action21",
	"Action22",
	"Action23",
	"Action24",
	"Action25",
	"Action26",
	"Action27",
	"Action28",
	"Action29",
	"Action30",
	"Action31",
	"Action32",
	"Action33",
	"Action34",
	"Action35",
	"Action36",
	"Action37",
	"Action38",
	"Action39",
	"Action40",
	"Action41",
	"Action42",
	"Action43",
	"Action44",
	"Action45",
	"Action46",
	"Action47",
	"Action48",
	"Action49",
	"Action50",
	"Action51",
}

type Uint interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

type token[U Uint] struct {
	pegRule
	begin, end U
}

func (t *token[_]) String() string {
	// \x1B[34m = blue
	// \x1B[m   = normal (disable color)
	return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v", rul3s[t.pegRule], t.begin, t.end)
}

type node[U Uint] struct {
	token[U]
	up, next *node[U]
}

func (n *node[U]) print(w io.Writer, pretty bool, buffer string) {
	var printFunc func(n *node[U], depth int)
	printFunc = func(n *node[U], depth int) {
		for n != nil {
			for range depth {
				fmt.Fprint(w, " ")
			}
			rule := rul3s[n.pegRule]
			quote := strconv.Quote(string([]rune(buffer)[n.begin:n.end]))
			if !pretty {
				fmt.Fprintf(w, "%v %v\n", rule, quote)
			} else {
				fmt.Fprintf(w, "\x1B[36m%v\x1B[m %v\n", rule, quote)
			}
			if n.up != nil {
				printFunc(n.up, depth+1)
			}
			n = n.next
		}
	}
	printFunc(n, 0)
}

func (n *node[_]) Print(w io.Writer, buffer string) {
	n.print(w, false, buffer)
}

func (n *node[_]) PrettyPrint(w io.Writer, buffer string) {
	n.print(w, true, buffer)
}

type tokens[U Uint] struct {
	tree []token[U]
}

func (t *tokens[_]) Trim(length uint32) {
	t.tree = t.tree[:length]
}

func (t *tokens[_]) Print() {
	for _, token := range t.tree {
		fmt.Println(token.String())
	}
}

func (t *tokens[U]) AST() *node[U] {
	type element struct {
		node *node[U]
		down *element
	}
	tokenSlice := t.Tokens()
	var stack *element
	for _, token := range tokenSlice {
		if token.begin == token.end {
			continue
		}
		node := &node[U]{token: token}
		for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
			stack.node.next = node.up
			node.up = stack.node
			stack = stack.down
		}
		stack = &element{node: node, down: stack}
	}
	if stack != nil {
		return stack.node
	}
	return nil
}

func (t *tokens[_]) PrintSyntaxTree(buffer string) {
	t.AST().Print(os.Stdout, buffer)
}

func (t *tokens[_]) WriteSyntaxTree(w io.Writer, buffer string) {
	t.AST().Print(w, buffer)
}

func (t *tokens[_]) PrettyPrintSyntaxTree(buffer string) {
	t.AST().PrettyPrint(os.Stdout, buffer)
}

func (t *tokens[U]) Add(rule pegRule, begin, end, index U) {
	tree, i := t.tree, int(index)
	newToken := token[U]{pegRule: rule, begin: begin, end: end}

	if i >= len(tree) {
		t.tree = append(tree, newToken)
		return
	}
	tree[i] = newToken
}

func (t *tokens[U]) Tokens() []token[U] {
	return t.tree
}

type Peg[U Uint] struct {
	*tree.Tree

	Buffer         string
	buffer         []rune
	rules          [101]func() bool
	parse          func(rule ...int) error
	reset          func()
	Pretty         bool
	disableMemoize bool
	tokens[U]
}

func (p *Peg[_]) Parse(rule ...int) error {
	return p.parse(rule...)
}

func (p *Peg[_]) Reset() {
	p.reset()
}

type textPosition struct {
	line, symbol int
}

type textPositionMap map[int]textPosition

func translatePositions(buffer []rune, positions []int) textPositionMap {
	length := len(positions)
	translations := make(textPositionMap, length)
	posIdx := 0
	line := 1
	symbol := 0

	slices.Sort(positions)

	for i, c := range buffer {
		if c == '\n' {
			line, symbol = line+1, 0
		} else {
			symbol++
		}
		if i == positions[posIdx] {
			translations[positions[posIdx]] = textPosition{line, symbol}
			for posIdx++; posIdx < length; posIdx++ {
				if i == positions[posIdx] {
					return translations
				}
			}
		}
		if posIdx >= length {
			break
		}
	}

	return translations
}

type parseError[U Uint] struct {
	p        *Peg[U]
	maxToken token[U]
}

func (e *parseError[U]) Error() string {
	tokenSlice, err := []token[U]{e.maxToken}, "\n"
	positions, p := make([]int, 2*len(tokenSlice)), 0
	for _, t := range tokenSlice {
		positions[p], p = int(t.begin), p+1
		positions[p], p = int(t.end), p+1
	}
	translations := translatePositions(e.p.buffer, positions)
	format := "parse error near %v (line %v symbol %v - line %v symbol %v):\n%v\n"
	if e.p.Pretty {
		format = "parse error near \x1B[34m%v\x1B[m (line %v symbol %v - line %v symbol %v):\n%v\n"
	}
	for _, t := range tokenSlice {
		begin, end := int(t.begin), int(t.end)
		err += fmt.Sprintf(format,
			rul3s[t.pegRule],
			translations[begin].line, translations[begin].symbol,
			translations[end].line, translations[end].symbol,
			strconv.Quote(string(e.p.buffer[begin:end])))
	}

	return err
}

func (p *Peg[_]) PrintSyntaxTree() {
	if p.Pretty {
		p.tokens.PrettyPrintSyntaxTree(p.Buffer)
	} else {
		p.tokens.PrintSyntaxTree(p.Buffer)
	}
}

func (p *Peg[_]) WriteSyntaxTree(w io.Writer) {
	p.tokens.WriteSyntaxTree(w, p.Buffer)
}

func (p *Peg[_]) SprintSyntaxTree() string {
	var b bytes.Buffer
	p.WriteSyntaxTree(&b)
	return b.String()
}

func (p *Peg[_]) Execute() {
	buffer, _buffer, text, begin, end := p.Buffer, p.buffer, "", 0, 0
	for _, t := range p.Tokens() {
		switch t.pegRule {

		case rulePegText:
			begin, end = int(t.begin), int(t.end)
			text = string(_buffer[begin:end])

		case ruleAction0:
			p.AddPackage(text)
		case ruleAction1:
			p.AddPeg(text)
		case ruleAction2:
			p.AddState(text)
		case ruleAction3:
			p.AddImportAlias(text)
		case ruleAction4:
			p.AddImport(text)
		case ruleAction5:
			p.AddRule(text)
		case ruleAction6:
			p.AddExpression()
		case ruleAction7:
			p.AddAlternate()
		case ruleAction8:
			p.AddNil()
			p.AddAlternate()
		case ruleAction9:
			p.AddNil()
		case ruleAction10:
			p.AddSequence()
		case ruleAction11:
			p.AddPredicate(text)
		case ruleAction12:
			p.AddStateChange(text)
		case ruleAction13:
			p.AddPeekFor()
		case ruleAction14:
			p.AddPeekNot()
		case ruleAction15:
			p.AddQuery()
		case ruleAction16:
			p.AddStar()
		case ruleAction17:
			p.AddPlus()
		case ruleAction18:
			p.AddName(text)
		case ruleAction19:
			p.AddDot()
		case ruleAction20:
			p.AddAction(text)
		case ruleAction21:
			p.AddPush()
		case ruleAction22:
			p.AddSequence()
		case ruleAction23:
			p.AddSequence()
		case ruleAction24:
			p.AddPeekNot()
			p.AddDot()
			p.AddSequence()
		case ruleAction25:
			p.AddPeekNot()
			p.AddDot()
			p.AddSequence()
		case ruleAction26:
			p.AddAlternate()
		case ruleAction27:
			p.AddAlternate()
		case ruleAction28:
			p.AddRange()
		case ruleAction29:
			p.AddDoubleRange()
		case ruleAction30:
			p.AddCharacter(text)
		case ruleAction31:
			p.AddDoubleCharacter(text)
		case ruleAction32:
			p.AddCharacter(text)
		case ruleAction33:
			p.AddCharacter("\a")
		case ruleAction34:
			p.AddCharacter("\b")
		case ruleAction35:
			p.AddCharacter("\x1B")
		case ruleAction36:
			p.AddCharacter("\f")
		case ruleAction37:
			p.AddCharacter("\n")
		case ruleAction38:
			p.AddCharacter("\r")
		case ruleAction39:
			p.AddCharacter("\t")
		case ruleAction40:
			p.AddCharacter("\v")
		case ruleAction41:
			p.AddCharacter("'")
		case ruleAction42:
			p.AddCharacter("\"")
		case ruleAction43:
			p.AddCharacter("[")
		case ruleAction44:
			p.AddCharacter("]")
		case ruleAction45:
			p.AddCharacter("-")
		case ruleAction46:
			p.AddHexaCharacter(text)
		case ruleAction47:
			p.AddOctalCharacter(text)
		case ruleAction48:
			p.AddOctalCharacter(text)
		case ruleAction49:
			p.AddCharacter("\\")
		case ruleAction50:
			p.AddSpace(text)
		case ruleAction51:
			p.AddComment(text)

		}
	}
	_, _, _, _, _ = buffer, _buffer, text, begin, end
}

func Pretty[U Uint](pretty bool) func(*Peg[U]) error {
	return func(p *Peg[U]) error {
		p.Pretty = pretty
		return nil
	}
}

func Size[U Uint](size int) func(*Peg[U]) error {
	return func(p *Peg[U]) error {
		p.tokens = tokens[U]{tree: make([]token[U], 0, size)}
		return nil
	}
}

func DisableMemoize[U Uint]() func(*Peg[U]) error {
	return func(p *Peg[U]) error {
		p.disableMemoize = true
		return nil
	}
}

type memo[U Uint] struct {
	Matched bool
	Partial []token[U]
}

type memoKey[U Uint] struct {
	Rule     U
	Position U
}

func (p *Peg[U]) Init(options ...func(*Peg[U]) error) error {
	var (
		maxToken             token[U]
		position, tokenIndex U
		buffer               []rune
		memoization          map[memoKey[U]]memo[U]
	)
	for _, option := range options {
		err := option(p)
		if err != nil {
			return err
		}
	}
	p.reset = func() {
		maxToken = token[U]{}
		position, tokenIndex = 0, 0
		memoization = make(map[memoKey[U]]memo[U])
		p.buffer = []rune(p.Buffer)
		if len(p.buffer) == 0 || p.buffer[len(p.buffer)-1] != endSymbol {
			p.buffer = append(p.buffer, endSymbol)
		}
		buffer = p.buffer
	}
	p.reset()

	_rules := p.rules
	tree := p.tokens
	p.parse = func(rule ...int) error {
		r := 1
		if len(rule) > 0 {
			r = rule[0]
		}
		matches := p.rules[r]()
		p.tokens = tree
		if matches {
			p.Trim(uint32(tokenIndex))
			return nil
		}
		return &parseError[U]{p, maxToken}
	}

	add := func(rule pegRule, begin U) {
		tree.Add(rule, begin, position, tokenIndex)
		tokenIndex++
		if begin != position && position > maxToken.end {
			maxToken = token[U]{rule, begin, position}
		}
	}

	memoize := func(rule U, begin U, tokenIndexStart U, matched bool) {
		if p.disableMemoize {
			return
		}
		key := memoKey[U]{rule, begin}
		if !matched {
			memoization[key] = memo[U]{Matched: false}
		} else {
			memoization[key] = memo[U]{
				Matched: true,
				Partial: slices.Clone(tree.tree[tokenIndexStart:tokenIndex]),
			}
		}
	}

	memoizedResult := func(m memo[U]) bool {
		if !m.Matched {
			return false
		}
		tree.tree = append(tree.tree[:tokenIndex], m.Partial...)
		tokenIndex += U(len(m.Partial))
		position = m.Partial[len(m.Partial)-1].end
		if tree.tree[tokenIndex-1].begin != position && position > maxToken.end {
			maxToken = tree.tree[tokenIndex-1]
		}
		return true
	}

	matchDot := func() bool {
		if buffer[position] != endSymbol {
			position++
			return true
		}
		return false
	}

	_rules = [...]func() bool{
		nil,

		/* 0 Grammar <- <(Header ('p' 'a' 'c' 'k' 'a' 'g' 'e') MustSpacing Identifier Action0 Import* ('t' 'y' 'p' 'e') MustSpacing Identifier Action1 ('P' 'e' 'g') Spacing Action Action2 Definition+ EndOfFile)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{0, position}]; ok {
				return memoizedResult(memoized)
			}
			position0, tokenIndex0 := position, tokenIndex
			{
				position1 := position
				{
					position2 := position
				l3:
					{
						position4, tokenIndex4 := position, tokenIndex
						{
							position5 := position
							{
								position6, tokenIndex6 := position, tokenIndex
								{
									position8 := position
									{
										position9, tokenIndex9 := position, tokenIndex
										if buffer[position] != '#' {
											goto l10
										}
										position++
										goto l9
									l10:
										position, tokenIndex = position9, tokenIndex9
										if buffer[position] != '/' {
											goto l7
										}
										position++
										if buffer[position] != '/' {
											goto l7
										}
										position++
									}
								l9:
									{
										position11 := position
									l12:
										{
											position13, tokenIndex13 := position, tokenIndex
											{
												position14, tokenIndex14 := position, tokenIndex
												if !_rules[ruleEndOfLine]() {
													goto l14
												}
												goto l13
											l14:
												position, tokenIndex = position14, tokenIndex14
											}
											if !matchDot() {
												goto l13
											}
											goto l12
										l13:
											position, tokenIndex = position13, tokenIndex13
										}
										add(rulePegText, position11)
									}
									{
										add(ruleAction51, position)
									}
									if !_rules[ruleEndOfLine]() {
										goto l7
									}
									add(ruleHeaderComment, position8)
								}
								goto l6
							l7:
								position, tokenIndex = position6, tokenIndex6
								{
									position16 := position
									if !_rules[ruleSpace]() {
										goto l4
									}
								l17:
									{
										position18, tokenIndex18 := position, tokenIndex
										if !_rules[ruleSpace]() {
											goto l18
										}
										goto l17
									l18:
										position, tokenIndex = position18, tokenIndex18
									}
									add(rulePegText, position16)
								}
								{
									add(ruleAction50, position)
								}
							}
						l6:
							add(ruleHeaderSpaceComment, position5)
						}
						goto l3
					l4:
						position, tokenIndex = position4, tokenIndex4
					}
					add(ruleHeader, position2)
				}
				if buffer[position] != 'p' {
					goto l0
				}
				position++
				if buffer[position] != 'a' {
					goto l0
				}
				position++
				if buffer[position] != 'c' {
					goto l0
				}
				position++
				if buffer[position] != 'k' {
					goto l0
				}
				position++
				if buffer[position] != 'a' {
					goto l0
				}
				position++
				if buffer[position] != 'g' {
					goto l0
				}
				position++
				if buffer[position] != 'e' {
					goto l0
				}
				position++
				if !_rules[ruleMustSpacing]() {
					goto l0
				}
				if !_rules[ruleIdentifier]() {
					goto l0
				}
				{
					add(ruleAction0, position)
				}
			l21:
				{
					position22, tokenIndex22 := position, tokenIndex
					{
						position23 := position
						if buffer[position] != 'i' {
							goto l22
						}
						position++
						if buffer[position] != 'm' {
							goto l22
						}
						position++
						if buffer[position] != 'p' {
							goto l22
						}
						position++
						if buffer[position] != 'o' {
							goto l22
						}
						position++
						if buffer[position] != 'r' {
							goto l22
						}
						position++
						if buffer[position] != 't' {
							goto l22
						}
						position++
						_rules[ruleSpacing]()
						{
							position24, tokenIndex24 := position, tokenIndex
							{
								position26 := position
								if buffer[position] != '(' {
									goto l25
								}
								position++
								_rules[ruleSpacing]()
							l27:
								{
									position28, tokenIndex28 := position, tokenIndex
									if !_rules[ruleImportName]() {
										goto l28
									}
									if buffer[position] != '\n' {
										goto l28
									}
									position++
									_rules[ruleSpacing]()
									goto l27
								l28:
									position, tokenIndex = position28, tokenIndex28
								}
								_rules[ruleSpacing]()
								if buffer[position] != ')' {
									goto l25
								}
								position++
								add(ruleMultiImport, position26)
							}
							goto l24
						l25:
							position, tokenIndex = position24, tokenIndex24
							{
								position29 := position
								if !_rules[ruleImportName]() {
									goto l22
								}
								add(ruleSingleImport, position29)
							}
						}
					l24:
						_rules[ruleSpacing]()
						add(ruleImport, position23)
					}
					goto l21
				l22:
					position, tokenIndex = position22, tokenIndex22
				}
				if buffer[position] != 't' {
					goto l0
				}
				position++
				if buffer[position] != 'y' {
					goto l0
				}
				position++
				if buffer[position] != 'p' {
					goto l0
				}
				position++
				if buffer[position] != 'e' {
					goto l0
				}
				position++
				if !_rules[ruleMustSpacing]() {
					goto l0
				}
				if !_rules[ruleIdentifier]() {
					goto l0
				}
				{
					add(ruleAction1, position)
				}
				if buffer[position] != 'P' {
					goto l0
				}
				position++
				if buffer[position] != 'e' {
					goto l0
				}
				position++
				if buffer[position] != 'g' {
					goto l0
				}
				position++
				_rules[ruleSpacing]()
				if !_rules[ruleAction]() {
					goto l0
				}
				{
					add(ruleAction2, position)
				}
				{
					position34 := position
					if !_rules[ruleIdentifier]() {
						goto l0
					}
					{
						add(ruleAction5, position)
					}
					if !_rules[ruleLeftArrow]() {
						goto l0
					}
					_rules[ruleExpression]()
					{
						add(ruleAction6, position)
					}
					{
						position37, tokenIndex37 := position, tokenIndex
						{
							position38, tokenIndex38 := position, tokenIndex
							if !_rules[ruleIdentifier]() {
								goto l39
							}
							if !_rules[ruleLeftArrow]() {
								goto l39
							}
							goto l38
						l39:
							position, tokenIndex = position38, tokenIndex38
							{
								position40, tokenIndex40 := position, tokenIndex
								if !matchDot() {
									goto l40
								}
								goto l0
							l40:
								position, tokenIndex = position40, tokenIndex40
							}
						}
					l38:
						position, tokenIndex = position37, tokenIndex37
					}
					add(ruleDefinition, position34)
				}
			l32:
				{
					position33, tokenIndex33 := position, tokenIndex
					{
						position41 := position
						if !_rules[ruleIdentifier]() {
							goto l33
						}
						{
							add(ruleAction5, position)
						}
						if !_rules[ruleLeftArrow]() {
							goto l33
						}
						_rules[ruleExpression]()
						{
							add(ruleAction6, position)
						}
						{
							position44, tokenIndex44 := position, tokenIndex
							{
								position45, tokenIndex45 := position, tokenIndex
								if !_rules[ruleIdentifier]() {
									goto l46
								}
								if !_rules[ruleLeftArrow]() {
									goto l46
								}
								goto l45
							l46:
								position, tokenIndex = position45, tokenIndex45
								{
									position47, tokenIndex47 := position, tokenIndex
									if !matchDot() {
										goto l47
									}
									goto l33
								l47:
									position, tokenIndex = position47, tokenIndex47
								}
							}
						l45:
							position, tokenIndex = position44, tokenIndex44
						}
						add(ruleDefinition, position41)
					}
					goto l32
				l33:
					position, tokenIndex = position33, tokenIndex33
				}
				{
					position48 := position
					{
						position49, tokenIndex49 := position, tokenIndex
						if !matchDot() {
							goto l49
						}
						goto l0
					l49:
						position, tokenIndex = position49, tokenIndex49
					}
					add(ruleEndOfFile, position48)
				}
				add(ruleGrammar, position1)
			}
			memoize(0, position0, tokenIndex0, true)
			return true
		l0:
			memoize(0, position0, tokenIndex0, false)
			position, tokenIndex = position0, tokenIndex0
			return false
		},
		/* 1 Import <- <('i' 'm' 'p' 'o' 'r' 't' Spacing (MultiImport / SingleImport) Spacing)> */
		nil,
		/* 2 SingleImport <- <ImportName> */
		nil,
		/* 3 MultiImport <- <('(' Spacing (ImportName '\n' Spacing)* Spacing ')')> */
		nil,
		/* 4 ImportName <- <((Identifier Action3)? '"' <((&('-') '-') | (&('.') '.') | (&('/') '/') | (&('_') '_') | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z') [A-Z]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]) | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') [a-z]))+> '"' Action4)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{4, position}]; ok {
				return memoizedResult(memoized)
			}
			position53, tokenIndex53 := position, tokenIndex
			{
				position54 := position
				{
					position55, tokenIndex55 := position, tokenIndex
					if !_rules[ruleIdentifier]() {
						goto l55
					}
					{
						add(ruleAction3, position)
					}
					goto l56
				l55:
					position, tokenIndex = position55, tokenIndex55
				}
			l56:
				if buffer[position] != '"' {
					goto l53
				}
				position++
				{
					position58 := position
					{
						switch buffer[position] {
						case '-':
							position++
						case '.':
							position++
						case '/':
							position++
						case '_':
							position++
						case 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z':
							position++
						case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
							position++
						default:
							if c := buffer[position]; c < 'a' || c > 'z' {
								goto l53
							}
							position++
						}
					}

				l59:
					{
						position60, tokenIndex60 := position, tokenIndex
						{
							switch buffer[position] {
							case '-':
								position++
							case '.':
								position++
							case '/':
								position++
							case '_':
								position++
							case 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z':
								position++
							case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
								position++
							default:
								if c := buffer[position]; c < 'a' || c > 'z' {
									goto l60
								}
								position++
							}
						}

						goto l59
					l60:
						position, tokenIndex = position60, tokenIndex60
					}
					add(rulePegText, position58)
				}
				if buffer[position] != '"' {
					goto l53
				}
				position++
				{
					add(ruleAction4, position)
				}
				add(ruleImportName, position54)
			}
			memoize(4, position53, tokenIndex53, true)
			return true
		l53:
			memoize(4, position53, tokenIndex53, false)
			position, tokenIndex = position53, tokenIndex53
			return false
		},
		/* 5 Definition <- <(Identifier Action5 LeftArrow Expression Action6 &((Identifier LeftArrow) / !.))> */
		nil,
		/* 6 Expression <- <((Sequence (Slash Sequence Action7)* (Slash Action8)?) / Action9)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{6, position}]; ok {
				return memoizedResult(memoized)
			}
			position65, tokenIndex65 := position, tokenIndex
			{
				position66 := position
				{
					position67, tokenIndex67 := position, tokenIndex
					if !_rules[ruleSequence]() {
						goto l68
					}
				l69:
					{
						position70, tokenIndex70 := position, tokenIndex
						if !_rules[ruleSlash]() {
							goto l70
						}
						if !_rules[ruleSequence]() {
							goto l70
						}
						{
							add(ruleAction7, position)
						}
						goto l69
					l70:
						position, tokenIndex = position70, tokenIndex70
					}
					{
						position72, tokenIndex72 := position, tokenIndex
						if !_rules[ruleSlash]() {
							goto l72
						}
						{
							add(ruleAction8, position)
						}
						goto l73
					l72:
						position, tokenIndex = position72, tokenIndex72
					}
				l73:
					goto l67
				l68:
					position, tokenIndex = position67, tokenIndex67
					{
						add(ruleAction9, position)
					}
				}
			l67:
				add(ruleExpression, position66)
			}
			memoize(6, position65, tokenIndex65, true)
			return true
		},
		/* 7 Sequence <- <(Prefix (Prefix Action10)*)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{7, position}]; ok {
				return memoizedResult(memoized)
			}
			position76, tokenIndex76 := position, tokenIndex
			{
				position77 := position
				if !_rules[rulePrefix]() {
					goto l76
				}
			l78:
				{
					position79, tokenIndex79 := position, tokenIndex
					if !_rules[rulePrefix]() {
						goto l79
					}
					{
						add(ruleAction10, position)
					}
					goto l78
				l79:
					position, tokenIndex = position79, tokenIndex79
				}
				add(ruleSequence, position77)
			}
			memoize(7, position76, tokenIndex76, true)
			return true
		l76:
			memoize(7, position76, tokenIndex76, false)
			position, tokenIndex = position76, tokenIndex76
			return false
		},
		/* 8 Prefix <- <((And Action Action11) / (Not Action Action12) / ((&('!') (Not Suffix Action14)) | (&('&') (And Suffix Action13)) | (&('"' | '\'' | '(' | '.' | '<' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '_' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{') Suffix)))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{8, position}]; ok {
				return memoizedResult(memoized)
			}
			position81, tokenIndex81 := position, tokenIndex
			{
				position82 := position
				{
					position83, tokenIndex83 := position, tokenIndex
					if !_rules[ruleAnd]() {
						goto l84
					}
					if !_rules[ruleAction]() {
						goto l84
					}
					{
						add(ruleAction11, position)
					}
					goto l83
				l84:
					position, tokenIndex = position83, tokenIndex83
					if !_rules[ruleNot]() {
						goto l86
					}
					if !_rules[ruleAction]() {
						goto l86
					}
					{
						add(ruleAction12, position)
					}
					goto l83
				l86:
					position, tokenIndex = position83, tokenIndex83
					{
						switch buffer[position] {
						case '!':
							if !_rules[ruleNot]() {
								goto l81
							}
							if !_rules[ruleSuffix]() {
								goto l81
							}
							{
								add(ruleAction14, position)
							}
						case '&':
							if !_rules[ruleAnd]() {
								goto l81
							}
							if !_rules[ruleSuffix]() {
								goto l81
							}
							{
								add(ruleAction13, position)
							}
						default:
							if !_rules[ruleSuffix]() {
								goto l81
							}
						}
					}

				}
			l83:
				add(rulePrefix, position82)
			}
			memoize(8, position81, tokenIndex81, true)
			return true
		l81:
			memoize(8, position81, tokenIndex81, false)
			position, tokenIndex = position81, tokenIndex81
			return false
		},
		/* 9 Suffix <- <(Primary ((&('+') (Plus Action17)) | (&('*') (Star Action16)) | (&('?') (Question Action15)))?)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{9, position}]; ok {
				return memoizedResult(memoized)
			}
			position91, tokenIndex91 := position, tokenIndex
			{
				position92 := position
				{
					position93 := position
					{
						switch buffer[position] {
						case '<':
							{
								position95 := position
								position++
								_rules[ruleSpacing]()
								add(ruleBegin, position95)
							}
							_rules[ruleExpression]()
							{
								position96 := position
								if buffer[position] != '>' {
									goto l91
								}
								position++
								_rules[ruleSpacing]()
								add(ruleEnd, position96)
							}
							{
								add(ruleAction21, position)
							}
						case '{':
							if !_rules[ruleAction]() {
								goto l91
							}
							{
								add(ruleAction20, position)
							}
						case '.':
							{
								position99 := position
								position++
								_rules[ruleSpacing]()
								add(ruleDot, position99)
							}
							{
								add(ruleAction19, position)
							}
						case '[':
							{
								position101 := position
								{
									position102, tokenIndex102 := position, tokenIndex
									position++
									if buffer[position] != '[' {
										goto l103
									}
									position++
									{
										position104, tokenIndex104 := position, tokenIndex
										{
											position106, tokenIndex106 := position, tokenIndex
											if buffer[position] != '^' {
												goto l107
											}
											position++
											if !_rules[ruleDoubleRanges]() {
												goto l107
											}
											{
												add(ruleAction24, position)
											}
											goto l106
										l107:
											position, tokenIndex = position106, tokenIndex106
											if !_rules[ruleDoubleRanges]() {
												goto l104
											}
										}
									l106:
										goto l105
									l104:
										position, tokenIndex = position104, tokenIndex104
									}
								l105:
									if buffer[position] != ']' {
										goto l103
									}
									position++
									if buffer[position] != ']' {
										goto l103
									}
									position++
									goto l102
								l103:
									position, tokenIndex = position102, tokenIndex102
									if buffer[position] != '[' {
										goto l91
									}
									position++
									{
										position109, tokenIndex109 := position, tokenIndex
										{
											position111, tokenIndex111 := position, tokenIndex
											if buffer[position] != '^' {
												goto l112
											}
											position++
											if !_rules[ruleRanges]() {
												goto l112
											}
											{
												add(ruleAction25, position)
											}
											goto l111
										l112:
											position, tokenIndex = position111, tokenIndex111
											if !_rules[ruleRanges]() {
												goto l109
											}
										}
									l111:
										goto l110
									l109:
										position, tokenIndex = position109, tokenIndex109
									}
								l110:
									if buffer[position] != ']' {
										goto l91
									}
									position++
								}
							l102:
								_rules[ruleSpacing]()
								add(ruleClass, position101)
							}
						case '"', '\'':
							{
								position114 := position
								{
									position115, tokenIndex115 := position, tokenIndex
									if buffer[position] != '\'' {
										goto l116
									}
									position++
									{
										position117, tokenIndex117 := position, tokenIndex
										{
											position119, tokenIndex119 := position, tokenIndex
											if buffer[position] != '\'' {
												goto l119
											}
											position++
											goto l117
										l119:
											position, tokenIndex = position119, tokenIndex119
										}
										if !_rules[ruleChar]() {
											goto l117
										}
										goto l118
									l117:
										position, tokenIndex = position117, tokenIndex117
									}
								l118:
								l120:
									{
										position121, tokenIndex121 := position, tokenIndex
										{
											position122, tokenIndex122 := position, tokenIndex
											if buffer[position] != '\'' {
												goto l122
											}
											position++
											goto l121
										l122:
											position, tokenIndex = position122, tokenIndex122
										}
										if !_rules[ruleChar]() {
											goto l121
										}
										{
											add(ruleAction22, position)
										}
										goto l120
									l121:
										position, tokenIndex = position121, tokenIndex121
									}
									if buffer[position] != '\'' {
										goto l116
									}
									position++
									_rules[ruleSpacing]()
									goto l115
								l116:
									position, tokenIndex = position115, tokenIndex115
									if buffer[position] != '"' {
										goto l91
									}
									position++
									{
										position124, tokenIndex124 := position, tokenIndex
										{
											position126, tokenIndex126 := position, tokenIndex
											if buffer[position] != '"' {
												goto l126
											}
											position++
											goto l124
										l126:
											position, tokenIndex = position126, tokenIndex126
										}
										if !_rules[ruleDoubleChar]() {
											goto l124
										}
										goto l125
									l124:
										position, tokenIndex = position124, tokenIndex124
									}
								l125:
								l127:
									{
										position128, tokenIndex128 := position, tokenIndex
										{
											position129, tokenIndex129 := position, tokenIndex
											if buffer[position] != '"' {
												goto l129
											}
											position++
											goto l128
										l129:
											position, tokenIndex = position129, tokenIndex129
										}
										if !_rules[ruleDoubleChar]() {
											goto l128
										}
										{
											add(ruleAction23, position)
										}
										goto l127
									l128:
										position, tokenIndex = position128, tokenIndex128
									}
									if buffer[position] != '"' {
										goto l91
									}
									position++
									_rules[ruleSpacing]()
								}
							l115:
								add(ruleLiteral, position114)
							}
						case '(':
							{
								position131 := position
								position++
								_rules[ruleSpacing]()
								add(ruleOpen, position131)
							}
							_rules[ruleExpression]()
							{
								position132 := position
								if buffer[position] != ')' {
									goto l91
								}
								position++
								_rules[ruleSpacing]()
								add(ruleClose, position132)
							}
						default:
							if !_rules[ruleIdentifier]() {
								goto l91
							}
							{
								position133, tokenIndex133 := position, tokenIndex
								if !_rules[ruleLeftArrow]() {
									goto l133
								}
								goto l91
							l133:
								position, tokenIndex = position133, tokenIndex133
							}
							{
								add(ruleAction18, position)
							}
						}
					}

					add(rulePrimary, position93)
				}
				{
					position135, tokenIndex135 := position, tokenIndex
					{
						switch buffer[position] {
						case '+':
							{
								position138 := position
								position++
								_rules[ruleSpacing]()
								add(rulePlus, position138)
							}
							{
								add(ruleAction17, position)
							}
						case '*':
							{
								position140 := position
								position++
								_rules[ruleSpacing]()
								add(ruleStar, position140)
							}
							{
								add(ruleAction16, position)
							}
						default:
							{
								position142 := position
								if buffer[position] != '?' {
									goto l135
								}
								position++
								_rules[ruleSpacing]()
								add(ruleQuestion, position142)
							}
							{
								add(ruleAction15, position)
							}
						}
					}

					goto l136
				l135:
					position, tokenIndex = position135, tokenIndex135
				}
			l136:
				add(ruleSuffix, position92)
			}
			memoize(9, position91, tokenIndex91, true)
			return true
		l91:
			memoize(9, position91, tokenIndex91, false)
			position, tokenIndex = position91, tokenIndex91
			return false
		},
		/* 10 Primary <- <((&('<') (Begin Expression End Action21)) | (&('{') (Action Action20)) | (&('.') (Dot Action19)) | (&('[') Class) | (&('"' | '\'') Literal) | (&('(') (Open Expression Close)) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '_' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') (Identifier !LeftArrow Action18)))> */
		nil,
		/* 11 Identifier <- <(<(IdentStart IdentCont*)> Spacing)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{11, position}]; ok {
				return memoizedResult(memoized)
			}
			position145, tokenIndex145 := position, tokenIndex
			{
				position146 := position
				{
					position147 := position
					if !_rules[ruleIdentStart]() {
						goto l145
					}
				l148:
					{
						position149, tokenIndex149 := position, tokenIndex
						{
							position150 := position
							{
								position151, tokenIndex151 := position, tokenIndex
								if !_rules[ruleIdentStart]() {
									goto l152
								}
								goto l151
							l152:
								position, tokenIndex = position151, tokenIndex151
								if c := buffer[position]; c < '0' || c > '9' {
									goto l149
								}
								position++
							}
						l151:
							add(ruleIdentCont, position150)
						}
						goto l148
					l149:
						position, tokenIndex = position149, tokenIndex149
					}
					add(rulePegText, position147)
				}
				_rules[ruleSpacing]()
				add(ruleIdentifier, position146)
			}
			memoize(11, position145, tokenIndex145, true)
			return true
		l145:
			memoize(11, position145, tokenIndex145, false)
			position, tokenIndex = position145, tokenIndex145
			return false
		},
		/* 12 IdentStart <- <((&('_') '_') | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z') [A-Z]) | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') [a-z]))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{12, position}]; ok {
				return memoizedResult(memoized)
			}
			position153, tokenIndex153 := position, tokenIndex
			{
				position154 := position
				{
					switch buffer[position] {
					case '_':
						position++
					case 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z':
						position++
					default:
						if c := buffer[position]; c < 'a' || c > 'z' {
							goto l153
						}
						position++
					}
				}

				add(ruleIdentStart, position154)
			}
			memoize(12, position153, tokenIndex153, true)
			return true
		l153:
			memoize(12, position153, tokenIndex153, false)
			position, tokenIndex = position153, tokenIndex153
			return false
		},
		/* 13 IdentCont <- <(IdentStart / [0-9])> */
		nil,
		/* 14 Literal <- <(('\'' (!'\'' Char)? (!'\'' Char Action22)* '\'' Spacing) / ('"' (!'"' DoubleChar)? (!'"' DoubleChar Action23)* '"' Spacing))> */
		nil,
		/* 15 Class <- <((('[' '[' (('^' DoubleRanges Action24) / DoubleRanges)? (']' ']')) / ('[' (('^' Ranges Action25) / Ranges)? ']')) Spacing)> */
		nil,
		/* 16 Ranges <- <(!']' Range (!']' Range Action26)*)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{16, position}]; ok {
				return memoizedResult(memoized)
			}
			position159, tokenIndex159 := position, tokenIndex
			{
				position160 := position
				{
					position161, tokenIndex161 := position, tokenIndex
					if buffer[position] != ']' {
						goto l161
					}
					position++
					goto l159
				l161:
					position, tokenIndex = position161, tokenIndex161
				}
				if !_rules[ruleRange]() {
					goto l159
				}
			l162:
				{
					position163, tokenIndex163 := position, tokenIndex
					{
						position164, tokenIndex164 := position, tokenIndex
						if buffer[position] != ']' {
							goto l164
						}
						position++
						goto l163
					l164:
						position, tokenIndex = position164, tokenIndex164
					}
					if !_rules[ruleRange]() {
						goto l163
					}
					{
						add(ruleAction26, position)
					}
					goto l162
				l163:
					position, tokenIndex = position163, tokenIndex163
				}
				add(ruleRanges, position160)
			}
			memoize(16, position159, tokenIndex159, true)
			return true
		l159:
			memoize(16, position159, tokenIndex159, false)
			position, tokenIndex = position159, tokenIndex159
			return false
		},
		/* 17 DoubleRanges <- <(!(']' ']') DoubleRange (!(']' ']') DoubleRange Action27)*)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{17, position}]; ok {
				return memoizedResult(memoized)
			}
			position166, tokenIndex166 := position, tokenIndex
			{
				position167 := position
				{
					position168, tokenIndex168 := position, tokenIndex
					if buffer[position] != ']' {
						goto l168
					}
					position++
					if buffer[position] != ']' {
						goto l168
					}
					position++
					goto l166
				l168:
					position, tokenIndex = position168, tokenIndex168
				}
				if !_rules[ruleDoubleRange]() {
					goto l166
				}
			l169:
				{
					position170, tokenIndex170 := position, tokenIndex
					{
						position171, tokenIndex171 := position, tokenIndex
						if buffer[position] != ']' {
							goto l171
						}
						position++
						if buffer[position] != ']' {
							goto l171
						}
						position++
						goto l170
					l171:
						position, tokenIndex = position171, tokenIndex171
					}
					if !_rules[ruleDoubleRange]() {
						goto l170
					}
					{
						add(ruleAction27, position)
					}
					goto l169
				l170:
					position, tokenIndex = position170, tokenIndex170
				}
				add(ruleDoubleRanges, position167)
			}
			memoize(17, position166, tokenIndex166, true)
			return true
		l166:
			memoize(17, position166, tokenIndex166, false)
			position, tokenIndex = position166, tokenIndex166
			return false
		},
		/* 18 Range <- <((Char '-' Char Action28) / Char)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{18, position}]; ok {
				return memoizedResult(memoized)
			}
			position173, tokenIndex173 := position, tokenIndex
			{
				position174 := position
				{
					position175, tokenIndex175 := position, tokenIndex
					if !_rules[ruleChar]() {
						goto l176
					}
					if buffer[position] != '-' {
						goto l176
					}
					position++
					if !_rules[ruleChar]() {
						goto l176
					}
					{
						add(ruleAction28, position)
					}
					goto l175
				l176:
					position, tokenIndex = position175, tokenIndex175
					if !_rules[ruleChar]() {
						goto l173
					}
				}
			l175:
				add(ruleRange, position174)
			}
			memoize(18, position173, tokenIndex173, true)
			return true
		l173:
			memoize(18, position173, tokenIndex173, false)
			position, tokenIndex = position173, tokenIndex173
			return false
		},
		/* 19 DoubleRange <- <((Char '-' Char Action29) / DoubleChar)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{19, position}]; ok {
				return memoizedResult(memoized)
			}
			position178, tokenIndex178 := position, tokenIndex
			{
				position179 := position
				{
					position180, tokenIndex180 := position, tokenIndex
					if !_rules[ruleChar]() {
						goto l181
					}
					if buffer[position] != '-' {
						goto l181
					}
					position++
					if !_rules[ruleChar]() {
						goto l181
					}
					{
						add(ruleAction29, position)
					}
					goto l180
				l181:
					position, tokenIndex = position180, tokenIndex180
					if !_rules[ruleDoubleChar]() {
						goto l178
					}
				}
			l180:
				add(ruleDoubleRange, position179)
			}
			memoize(19, position178, tokenIndex178, true)
			return true
		l178:
			memoize(19, position178, tokenIndex178, false)
			position, tokenIndex = position178, tokenIndex178
			return false
		},
		/* 20 Char <- <(Escape / (!'\\' <.> Action30))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{20, position}]; ok {
				return memoizedResult(memoized)
			}
			position183, tokenIndex183 := position, tokenIndex
			{
				position184 := position
				{
					position185, tokenIndex185 := position, tokenIndex
					if !_rules[ruleEscape]() {
						goto l186
					}
					goto l185
				l186:
					position, tokenIndex = position185, tokenIndex185
					{
						position187, tokenIndex187 := position, tokenIndex
						if buffer[position] != '\\' {
							goto l187
						}
						position++
						goto l183
					l187:
						position, tokenIndex = position187, tokenIndex187
					}
					{
						position188 := position
						if !matchDot() {
							goto l183
						}
						add(rulePegText, position188)
					}
					{
						add(ruleAction30, position)
					}
				}
			l185:
				add(ruleChar, position184)
			}
			memoize(20, position183, tokenIndex183, true)
			return true
		l183:
			memoize(20, position183, tokenIndex183, false)
			position, tokenIndex = position183, tokenIndex183
			return false
		},
		/* 21 DoubleChar <- <(Escape / (<([a-z] / [A-Z])> Action31) / (!'\\' <.> Action32))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{21, position}]; ok {
				return memoizedResult(memoized)
			}
			position190, tokenIndex190 := position, tokenIndex
			{
				position191 := position
				{
					position192, tokenIndex192 := position, tokenIndex
					if !_rules[ruleEscape]() {
						goto l193
					}
					goto l192
				l193:
					position, tokenIndex = position192, tokenIndex192
					{
						position195 := position
						{
							position196, tokenIndex196 := position, tokenIndex
							if c := buffer[position]; c < 'a' || c > 'z' {
								goto l197
							}
							position++
							goto l196
						l197:
							position, tokenIndex = position196, tokenIndex196
							if c := buffer[position]; c < 'A' || c > 'Z' {
								goto l194
							}
							position++
						}
					l196:
						add(rulePegText, position195)
					}
					{
						add(ruleAction31, position)
					}
					goto l192
				l194:
					position, tokenIndex = position192, tokenIndex192
					{
						position199, tokenIndex199 := position, tokenIndex
						if buffer[position] != '\\' {
							goto l199
						}
						position++
						goto l190
					l199:
						position, tokenIndex = position199, tokenIndex199
					}
					{
						position200 := position
						if !matchDot() {
							goto l190
						}
						add(rulePegText, position200)
					}
					{
						add(ruleAction32, position)
					}
				}
			l192:
				add(ruleDoubleChar, position191)
			}
			memoize(21, position190, tokenIndex190, true)
			return true
		l190:
			memoize(21, position190, tokenIndex190, false)
			position, tokenIndex = position190, tokenIndex190
			return false
		},
		/* 22 Escape <- <(('\\' ('a' / 'A') Action33) / ('\\' ('b' / 'B') Action34) / ('\\' ('e' / 'E') Action35) / ('\\' ('f' / 'F') Action36) / ('\\' ('n' / 'N') Action37) / ('\\' ('r' / 'R') Action38) / ('\\' ('t' / 'T') Action39) / ('\\' ('v' / 'V') Action40) / ('\\' '\'' Action41) / ('\\' '"' Action42) / ('\\' '[' Action43) / ('\\' ']' Action44) / ('\\' '-' Action45) / ('\\' ('0' ('x' / 'X')) <((&('A' | 'B' | 'C' | 'D' | 'E' | 'F') [A-F]) | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f') [a-f]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]))+> Action46) / ('\\' <([0-3] [0-7] [0-7])> Action47) / ('\\' <([0-7] [0-7]?)> Action48) / ('\\' '\\' Action49))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{22, position}]; ok {
				return memoizedResult(memoized)
			}
			position202, tokenIndex202 := position, tokenIndex
			{
				position203 := position
				{
					position204, tokenIndex204 := position, tokenIndex
					if buffer[position] != '\\' {
						goto l205
					}
					position++
					{
						position206, tokenIndex206 := position, tokenIndex
						if buffer[position] != 'a' {
							goto l207
						}
						position++
						goto l206
					l207:
						position, tokenIndex = position206, tokenIndex206
						if buffer[position] != 'A' {
							goto l205
						}
						position++
					}
				l206:
					{
						add(ruleAction33, position)
					}
					goto l204
				l205:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l209
					}
					position++
					{
						position210, tokenIndex210 := position, tokenIndex
						if buffer[position] != 'b' {
							goto l211
						}
						position++
						goto l210
					l211:
						position, tokenIndex = position210, tokenIndex210
						if buffer[position] != 'B' {
							goto l209
						}
						position++
					}
				l210:
					{
						add(ruleAction34, position)
					}
					goto l204
				l209:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l213
					}
					position++
					{
						position214, tokenIndex214 := position, tokenIndex
						if buffer[position] != 'e' {
							goto l215
						}
						position++
						goto l214
					l215:
						position, tokenIndex = position214, tokenIndex214
						if buffer[position] != 'E' {
							goto l213
						}
						position++
					}
				l214:
					{
						add(ruleAction35, position)
					}
					goto l204
				l213:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l217
					}
					position++
					{
						position218, tokenIndex218 := position, tokenIndex
						if buffer[position] != 'f' {
							goto l219
						}
						position++
						goto l218
					l219:
						position, tokenIndex = position218, tokenIndex218
						if buffer[position] != 'F' {
							goto l217
						}
						position++
					}
				l218:
					{
						add(ruleAction36, position)
					}
					goto l204
				l217:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l221
					}
					position++
					{
						position222, tokenIndex222 := position, tokenIndex
						if buffer[position] != 'n' {
							goto l223
						}
						position++
						goto l222
					l223:
						position, tokenIndex = position222, tokenIndex222
						if buffer[position] != 'N' {
							goto l221
						}
						position++
					}
				l222:
					{
						add(ruleAction37, position)
					}
					goto l204
				l221:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l225
					}
					position++
					{
						position226, tokenIndex226 := position, tokenIndex
						if buffer[position] != 'r' {
							goto l227
						}
						position++
						goto l226
					l227:
						position, tokenIndex = position226, tokenIndex226
						if buffer[position] != 'R' {
							goto l225
						}
						position++
					}
				l226:
					{
						add(ruleAction38, position)
					}
					goto l204
				l225:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l229
					}
					position++
					{
						position230, tokenIndex230 := position, tokenIndex
						if buffer[position] != 't' {
							goto l231
						}
						position++
						goto l230
					l231:
						position, tokenIndex = position230, tokenIndex230
						if buffer[position] != 'T' {
							goto l229
						}
						position++
					}
				l230:
					{
						add(ruleAction39, position)
					}
					goto l204
				l229:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l233
					}
					position++
					{
						position234, tokenIndex234 := position, tokenIndex
						if buffer[position] != 'v' {
							goto l235
						}
						position++
						goto l234
					l235:
						position, tokenIndex = position234, tokenIndex234
						if buffer[position] != 'V' {
							goto l233
						}
						position++
					}
				l234:
					{
						add(ruleAction40, position)
					}
					goto l204
				l233:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l237
					}
					position++
					if buffer[position] != '\'' {
						goto l237
					}
					position++
					{
						add(ruleAction41, position)
					}
					goto l204
				l237:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l239
					}
					position++
					if buffer[position] != '"' {
						goto l239
					}
					position++
					{
						add(ruleAction42, position)
					}
					goto l204
				l239:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l241
					}
					position++
					if buffer[position] != '[' {
						goto l241
					}
					position++
					{
						add(ruleAction43, position)
					}
					goto l204
				l241:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l243
					}
					position++
					if buffer[position] != ']' {
						goto l243
					}
					position++
					{
						add(ruleAction44, position)
					}
					goto l204
				l243:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l245
					}
					position++
					if buffer[position] != '-' {
						goto l245
					}
					position++
					{
						add(ruleAction45, position)
					}
					goto l204
				l245:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l247
					}
					position++
					if buffer[position] != '0' {
						goto l247
					}
					position++
					{
						position248, tokenIndex248 := position, tokenIndex
						if buffer[position] != 'x' {
							goto l249
						}
						position++
						goto l248
					l249:
						position, tokenIndex = position248, tokenIndex248
						if buffer[position] != 'X' {
							goto l247
						}
						position++
					}
				l248:
					{
						position250 := position
						{
							switch buffer[position] {
							case 'A', 'B', 'C', 'D', 'E', 'F':
								position++
							case 'a', 'b', 'c', 'd', 'e', 'f':
								position++
							default:
								if c := buffer[position]; c < '0' || c > '9' {
									goto l247
								}
								position++
							}
						}

					l251:
						{
							position252, tokenIndex252 := position, tokenIndex
							{
								switch buffer[position] {
								case 'A', 'B', 'C', 'D', 'E', 'F':
									position++
								case 'a', 'b', 'c', 'd', 'e', 'f':
									position++
								default:
									if c := buffer[position]; c < '0' || c > '9' {
										goto l252
									}
									position++
								}
							}

							goto l251
						l252:
							position, tokenIndex = position252, tokenIndex252
						}
						add(rulePegText, position250)
					}
					{
						add(ruleAction46, position)
					}
					goto l204
				l247:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l256
					}
					position++
					{
						position257 := position
						if c := buffer[position]; c < '0' || c > '3' {
							goto l256
						}
						position++
						if c := buffer[position]; c < '0' || c > '7' {
							goto l256
						}
						position++
						if c := buffer[position]; c < '0' || c > '7' {
							goto l256
						}
						position++
						add(rulePegText, position257)
					}
					{
						add(ruleAction47, position)
					}
					goto l204
				l256:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l259
					}
					position++
					{
						position260 := position
						if c := buffer[position]; c < '0' || c > '7' {
							goto l259
						}
						position++
						{
							position261, tokenIndex261 := position, tokenIndex
							if c := buffer[position]; c < '0' || c > '7' {
								goto l261
							}
							position++
							goto l262
						l261:
							position, tokenIndex = position261, tokenIndex261
						}
					l262:
						add(rulePegText, position260)
					}
					{
						add(ruleAction48, position)
					}
					goto l204
				l259:
					position, tokenIndex = position204, tokenIndex204
					if buffer[position] != '\\' {
						goto l202
					}
					position++
					if buffer[position] != '\\' {
						goto l202
					}
					position++
					{
						add(ruleAction49, position)
					}
				}
			l204:
				add(ruleEscape, position203)
			}
			memoize(22, position202, tokenIndex202, true)
			return true
		l202:
			memoize(22, position202, tokenIndex202, false)
			position, tokenIndex = position202, tokenIndex202
			return false
		},
		/* 23 LeftArrow <- <((('<' '-') / '←') Spacing)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{23, position}]; ok {
				return memoizedResult(memoized)
			}
			position265, tokenIndex265 := position, tokenIndex
			{
				position266 := position
				{
					position267, tokenIndex267 := position, tokenIndex
					if buffer[position] != '<' {
						goto l268
					}
					position++
					if buffer[position] != '-' {
						goto l268
					}
					position++
					goto l267
				l268:
					position, tokenIndex = position267, tokenIndex267
					if buffer[position] != '←' {
						goto l265
					}
					position++
				}
			l267:
				_rules[ruleSpacing]()
				add(ruleLeftArrow, position266)
			}
			memoize(23, position265, tokenIndex265, true)
			return true
		l265:
			memoize(23, position265, tokenIndex265, false)
			position, tokenIndex = position265, tokenIndex265
			return false
		},
		/* 24 Slash <- <('/' Spacing)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{24, position}]; ok {
				return memoizedResult(memoized)
			}
			position269, tokenIndex269 := position, tokenIndex
			{
				position270 := position
				if buffer[position] != '/' {
					goto l269
				}
				position++
				_rules[ruleSpacing]()
				add(ruleSlash, position270)
			}
			memoize(24, position269, tokenIndex269, true)
			return true
		l269:
			memoize(24, position269, tokenIndex269, false)
			position, tokenIndex = position269, tokenIndex269
			return false
		},
		/* 25 And <- <('&' Spacing)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{25, position}]; ok {
				return memoizedResult(memoized)
			}
			position271, tokenIndex271 := position, tokenIndex
			{
				position272 := position
				if buffer[position] != '&' {
					goto l271
				}
				position++
				_rules[ruleSpacing]()
				add(ruleAnd, position272)
			}
			memoize(25, position271, tokenIndex271, true)
			return true
		l271:
			memoize(25, position271, tokenIndex271, false)
			position, tokenIndex = position271, tokenIndex271
			return false
		},
		/* 26 Not <- <('!' Spacing)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{26, position}]; ok {
				return memoizedResult(memoized)
			}
			position273, tokenIndex273 := position, tokenIndex
			{
				position274 := position
				if buffer[position] != '!' {
					goto l273
				}
				position++
				_rules[ruleSpacing]()
				add(ruleNot, position274)
			}
			memoize(26, position273, tokenIndex273, true)
			return true
		l273:
			memoize(26, position273, tokenIndex273, false)
			position, tokenIndex = position273, tokenIndex273
			return false
		},
		/* 27 Question <- <('?' Spacing)> */
		nil,
		/* 28 Star <- <('*' Spacing)> */
		nil,
		/* 29 Plus <- <('+' Spacing)> */
		nil,
		/* 30 Open <- <('(' Spacing)> */
		nil,
		/* 31 Close <- <(')' Spacing)> */
		nil,
		/* 32 Dot <- <('.' Spacing)> */
		nil,
		/* 33 SpaceComment <- <(Space / Comment)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{33, position}]; ok {
				return memoizedResult(memoized)
			}
			position281, tokenIndex281 := position, tokenIndex
			{
				position282 := position
				{
					position283, tokenIndex283 := position, tokenIndex
					if !_rules[ruleSpace]() {
						goto l284
					}
					goto l283
				l284:
					position, tokenIndex = position283, tokenIndex283
					{
						position285 := position
						{
							position286, tokenIndex286 := position, tokenIndex
							if buffer[position] != '#' {
								goto l287
							}
							position++
							goto l286
						l287:
							position, tokenIndex = position286, tokenIndex286
							if buffer[position] != '/' {
								goto l281
							}
							position++
							if buffer[position] != '/' {
								goto l281
							}
							position++
						}
					l286:
					l288:
						{
							position289, tokenIndex289 := position, tokenIndex
							{
								position290, tokenIndex290 := position, tokenIndex
								if !_rules[ruleEndOfLine]() {
									goto l290
								}
								goto l289
							l290:
								position, tokenIndex = position290, tokenIndex290
							}
							if !matchDot() {
								goto l289
							}
							goto l288
						l289:
							position, tokenIndex = position289, tokenIndex289
						}
						if !_rules[ruleEndOfLine]() {
							goto l281
						}
						add(ruleComment, position285)
					}
				}
			l283:
				add(ruleSpaceComment, position282)
			}
			memoize(33, position281, tokenIndex281, true)
			return true
		l281:
			memoize(33, position281, tokenIndex281, false)
			position, tokenIndex = position281, tokenIndex281
			return false
		},
		/* 34 Spacing <- <SpaceComment*> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{34, position}]; ok {
				return memoizedResult(memoized)
			}
			position291, tokenIndex291 := position, tokenIndex
			{
				position292 := position
			l293:
				{
					position294, tokenIndex294 := position, tokenIndex
					if !_rules[ruleSpaceComment]() {
						goto l294
					}
					goto l293
				l294:
					position, tokenIndex = position294, tokenIndex294
				}
				add(ruleSpacing, position292)
			}
			memoize(34, position291, tokenIndex291, true)
			return true
		},
		/* 35 MustSpacing <- <SpaceComment+> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{35, position}]; ok {
				return memoizedResult(memoized)
			}
			position295, tokenIndex295 := position, tokenIndex
			{
				position296 := position
				if !_rules[ruleSpaceComment]() {
					goto l295
				}
			l297:
				{
					position298, tokenIndex298 := position, tokenIndex
					if !_rules[ruleSpaceComment]() {
						goto l298
					}
					goto l297
				l298:
					position, tokenIndex = position298, tokenIndex298
				}
				add(ruleMustSpacing, position296)
			}
			memoize(35, position295, tokenIndex295, true)
			return true
		l295:
			memoize(35, position295, tokenIndex295, false)
			position, tokenIndex = position295, tokenIndex295
			return false
		},
		/* 36 Comment <- <(('#' / ('/' '/')) (!EndOfLine .)* EndOfLine)> */
		nil,
		/* 37 Space <- <((&('\t') '\t') | (&(' ') ' ') | (&('\n' | '\r') EndOfLine))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{37, position}]; ok {
				return memoizedResult(memoized)
			}
			position300, tokenIndex300 := position, tokenIndex
			{
				position301 := position
				{
					switch buffer[position] {
					case '\t':
						position++
					case ' ':
						position++
					default:
						if !_rules[ruleEndOfLine]() {
							goto l300
						}
					}
				}

				add(ruleSpace, position301)
			}
			memoize(37, position300, tokenIndex300, true)
			return true
		l300:
			memoize(37, position300, tokenIndex300, false)
			position, tokenIndex = position300, tokenIndex300
			return false
		},
		/* 38 Header <- <HeaderSpaceComment*> */
		nil,
		/* 39 HeaderSpaceComment <- <(HeaderComment / (<Space+> Action50))> */
		nil,
		/* 40 HeaderComment <- <(('#' / ('/' '/')) <(!EndOfLine .)*> Action51 EndOfLine)> */
		nil,
		/* 41 EndOfLine <- <(('\r' '\n') / '\n' / '\r')> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{41, position}]; ok {
				return memoizedResult(memoized)
			}
			position306, tokenIndex306 := position, tokenIndex
			{
				position307 := position
				{
					position308, tokenIndex308 := position, tokenIndex
					if buffer[position] != '\r' {
						goto l309
					}
					position++
					if buffer[position] != '\n' {
						goto l309
					}
					position++
					goto l308
				l309:
					position, tokenIndex = position308, tokenIndex308
					if buffer[position] != '\n' {
						goto l310
					}
					position++
					goto l308
				l310:
					position, tokenIndex = position308, tokenIndex308
					if buffer[position] != '\r' {
						goto l306
					}
					position++
				}
			l308:
				add(ruleEndOfLine, position307)
			}
			memoize(41, position306, tokenIndex306, true)
			return true
		l306:
			memoize(41, position306, tokenIndex306, false)
			position, tokenIndex = position306, tokenIndex306
			return false
		},
		/* 42 EndOfFile <- <!.> */
		nil,
		/* 43 Action <- <('{' <ActionBody*> '}' Spacing)> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{43, position}]; ok {
				return memoizedResult(memoized)
			}
			position312, tokenIndex312 := position, tokenIndex
			{
				position313 := position
				if buffer[position] != '{' {
					goto l312
				}
				position++
				{
					position314 := position
				l315:
					{
						position316, tokenIndex316 := position, tokenIndex
						if !_rules[ruleActionBody]() {
							goto l316
						}
						goto l315
					l316:
						position, tokenIndex = position316, tokenIndex316
					}
					add(rulePegText, position314)
				}
				if buffer[position] != '}' {
					goto l312
				}
				position++
				_rules[ruleSpacing]()
				add(ruleAction, position313)
			}
			memoize(43, position312, tokenIndex312, true)
			return true
		l312:
			memoize(43, position312, tokenIndex312, false)
			position, tokenIndex = position312, tokenIndex312
			return false
		},
		/* 44 ActionBody <- <((!('{' / '}') .) / ('{' ActionBody* '}'))> */
		func() bool {
			if memoized, ok := memoization[memoKey[U]{44, position}]; ok {
				return memoizedResult(memoized)
			}
			position317, tokenIndex317 := position, tokenIndex
			{
				position318 := position
				{
					position319, tokenIndex319 := position, tokenIndex
					{
						position321, tokenIndex321 := position, tokenIndex
						{
							position322, tokenIndex322 := position, tokenIndex
							if buffer[position] != '{' {
								goto l323
							}
							position++
							goto l322
						l323:
							position, tokenIndex = position322, tokenIndex322
							if buffer[position] != '}' {
								goto l321
							}
							position++
						}
					l322:
						goto l320
					l321:
						position, tokenIndex = position321, tokenIndex321
					}
					if !matchDot() {
						goto l320
					}
					goto l319
				l320:
					position, tokenIndex = position319, tokenIndex319
					if buffer[position] != '{' {
						goto l317
					}
					position++
				l324:
					{
						position325, tokenIndex325 := position, tokenIndex
						if !_rules[ruleActionBody]() {
							goto l325
						}
						goto l324
					l325:
						position, tokenIndex = position325, tokenIndex325
					}
					if buffer[position] != '}' {
						goto l317
					}
					position++
				}
			l319:
				add(ruleActionBody, position318)
			}
			memoize(44, position317, tokenIndex317, true)
			return true
		l317:
			memoize(44, position317, tokenIndex317, false)
			position, tokenIndex = position317, tokenIndex317
			return false
		},
		/* 45 Begin <- <('<' Spacing)> */
		nil,
		/* 46 End <- <('>' Spacing)> */
		nil,
		/* 48 Action0 <- <{ p.AddPackage(text) }> */
		nil,
		/* 49 Action1 <- <{ p.AddPeg(text) }> */
		nil,
		/* 50 Action2 <- <{ p.AddState(text) }> */
		nil,
		/* 51 Action3 <- <{ p.AddImportAlias(text) }> */
		nil,
		nil,
		/* 53 Action4 <- <{ p.AddImport(text) }> */
		nil,
		/* 54 Action5 <- <{ p.AddRule(text) }> */
		nil,
		/* 55 Action6 <- <{ p.AddExpression() }> */
		nil,
		/* 56 Action7 <- <{ p.AddAlternate() }> */
		nil,
		/* 57 Action8 <- <{ p.AddNil(); p.AddAlternate() }> */
		nil,
		/* 58 Action9 <- <{ p.AddNil() }> */
		nil,
		/* 59 Action10 <- <{ p.AddSequence() }> */
		nil,
		/* 60 Action11 <- <{ p.AddPredicate(text) }> */
		nil,
		/* 61 Action12 <- <{ p.AddStateChange(text) }> */
		nil,
		/* 62 Action13 <- <{ p.AddPeekFor() }> */
		nil,
		/* 63 Action14 <- <{ p.AddPeekNot() }> */
		nil,
		/* 64 Action15 <- <{ p.AddQuery() }> */
		nil,
		/* 65 Action16 <- <{ p.AddStar() }> */
		nil,
		/* 66 Action17 <- <{ p.AddPlus() }> */
		nil,
		/* 67 Action18 <- <{ p.AddName(text) }> */
		nil,
		/* 68 Action19 <- <{ p.AddDot() }> */
		nil,
		/* 69 Action20 <- <{ p.AddAction(text) }> */
		nil,
		/* 70 Action21 <- <{ p.AddPush() }> */
		nil,
		/* 71 Action22 <- <{ p.AddSequence() }> */
		nil,
		/* 72 Action23 <- <{ p.AddSequence() }> */
		nil,
		/* 73 Action24 <- <{ p.AddPeekNot(); p.AddDot(); p.AddSequence() }> */
		nil,
		/* 74 Action25 <- <{ p.AddPeekNot(); p.AddDot(); p.AddSequence() }> */
		nil,
		/* 75 Action26 <- <{ p.AddAlternate() }> */
		nil,
		/* 76 Action27 <- <{ p.AddAlternate() }> */
		nil,
		/* 77 Action28 <- <{ p.AddRange() }> */
		nil,
		/* 78 Action29 <- <{ p.AddDoubleRange() }> */
		nil,
		/* 79 Action30 <- <{ p.AddCharacter(text) }> */
		nil,
		/* 80 Action31 <- <{ p.AddDoubleCharacter(text) }> */
		nil,
		/* 81 Action32 <- <{ p.AddCharacter(text) }> */
		nil,
		/* 82 Action33 <- <{ p.AddCharacter("\a") }> */
		nil,
		/* 83 Action34 <- <{ p.AddCharacter("\b") }> */
		nil,
		/* 84 Action35 <- <{ p.AddCharacter("\x1B") }> */
		nil,
		/* 85 Action36 <- <{ p.AddCharacter("\f") }> */
		nil,
		/* 86 Action37 <- <{ p.AddCharacter("\n") }> */
		nil,
		/* 87 Action38 <- <{ p.AddCharacter("\r") }> */
		nil,
		/* 88 Action39 <- <{ p.AddCharacter("\t") }> */
		nil,
		/* 89 Action40 <- <{ p.AddCharacter("\v") }> */
		nil,
		/* 90 Action41 <- <{ p.AddCharacter("'") }> */
		nil,
		/* 91 Action42 <- <{ p.AddCharacter("\"") }> */
		nil,
		/* 92 Action43 <- <{ p.AddCharacter("[") }> */
		nil,
		/* 93 Action44 <- <{ p.AddCharacter("]") }> */
		nil,
		/* 94 Action45 <- <{ p.AddCharacter("-") }> */
		nil,
		/* 95 Action46 <- <{ p.AddHexaCharacter(text) }> */
		nil,
		/* 96 Action47 <- <{ p.AddOctalCharacter(text) }> */
		nil,
		/* 97 Action48 <- <{ p.AddOctalCharacter(text) }> */
		nil,
		/* 98 Action49 <- <{ p.AddCharacter("\\") }> */
		nil,
		/* 99 Action50 <- <{ p.AddSpace(text) }> */
		nil,
		/* 100 Action51 <- <{ p.AddComment(text) }> */
		nil,
	}
	p.rules = _rules
	return nil
}