grammar.go

package stock_parser

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

import (
	"fmt"
	"io"
	"os"
	"sort"
	"strconv"
	"strings"
)

const endSymbol rune = 1114112

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

const (
	ruleUnknown pegRule = iota
	ruleItem
	ruleLine
	ruleOTHER
	ruleStock
	ruleXLStock
	ruleFTStock
	ruleStockName
	ruleCode
	ruleUSCode
	ruleHKCode
	ruleACode
	ruleHSCODE
	ruleLetter
	ruleNumber
	ruleSuffix
	ruleMarket
	ruleCNMarket
	ruleHKMarket
	ruleUSMarket
	ruleSGMarket
	ruleSP
)

var rul3s = [...]string{
	"Unknown",
	"Item",
	"Line",
	"OTHER",
	"Stock",
	"XLStock",
	"FTStock",
	"StockName",
	"Code",
	"USCode",
	"HKCode",
	"ACode",
	"HSCODE",
	"Letter",
	"Number",
	"Suffix",
	"Market",
	"CNMarket",
	"HKMarket",
	"USMarket",
	"SGMarket",
	"SP",
}

type token32 struct {
	pegRule
	begin, end uint32
}

func (t *token32) String() string {
	return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v", rul3s[t.pegRule], t.begin, t.end)
}

type node32 struct {
	token32
	up, next *node32
}

func (node *node32) print(w io.Writer, pretty bool, buffer string) {
	var print func(node *node32, depth int)
	print = func(node *node32, depth int) {
		for node != nil {
			for c := 0; c < depth; c++ {
				fmt.Fprintf(w, " ")
			}
			rule := rul3s[node.pegRule]
			quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.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 node.up != nil {
				print(node.up, depth+1)
			}
			node = node.next
		}
	}
	print(node, 0)
}

func (node *node32) Print(w io.Writer, buffer string) {
	node.print(w, false, buffer)
}

func (node *node32) PrettyPrint(w io.Writer, buffer string) {
	node.print(w, true, buffer)
}

type tokens32 struct {
	tree []token32
}

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

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

func (t *tokens32) AST() *node32 {
	type element struct {
		node *node32
		down *element
	}
	tokens := t.Tokens()
	var stack *element
	for _, token := range tokens {
		if token.begin == token.end {
			continue
		}
		node := &node32{token32: 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 *tokens32) PrintSyntaxTree(buffer string) {
	t.AST().Print(os.Stdout, buffer)
}

func (t *tokens32) WriteSyntaxTree(w io.Writer, buffer string) {
	t.AST().Print(w, buffer)
}

func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
	t.AST().PrettyPrint(os.Stdout, buffer)
}

func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
	tree, i := t.tree, int(index)
	if i >= len(tree) {
		t.tree = append(tree, token32{pegRule: rule, begin: begin, end: end})
		return
	}
	tree[i] = token32{pegRule: rule, begin: begin, end: end}
}

func (t *tokens32) Tokens() []token32 {
	return t.tree
}

type StockCodeParser struct {
	pos     int
	peekPos int

	Buffer string
	buffer []rune
	rules  [22]func() bool
	parse  func(rule ...int) error
	reset  func()
	Pretty bool
	tokens32
}

func (p *StockCodeParser) Parse(rule ...int) error {
	return p.parse(rule...)
}

func (p *StockCodeParser) Reset() {
	p.reset()
}

type textPosition struct {
	line, symbol int
}

type textPositionMap map[int]textPosition

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

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

	return translations
}

type parseError struct {
	p   *StockCodeParser
	max token32
}

func (e *parseError) Error() string {
	tokens, err := []token32{e.max}, "\n"
	positions, p := make([]int, 2*len(tokens)), 0
	for _, token := range tokens {
		positions[p], p = int(token.begin), p+1
		positions[p], p = int(token.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 _, token := range tokens {
		begin, end := int(token.begin), int(token.end)
		err += fmt.Sprintf(format,
			rul3s[token.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 *StockCodeParser) PrintSyntaxTree() {
	if p.Pretty {
		p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
	} else {
		p.tokens32.PrintSyntaxTree(p.Buffer)
	}
}

func (p *StockCodeParser) WriteSyntaxTree(w io.Writer) {
	p.tokens32.WriteSyntaxTree(w, p.Buffer)
}

func (p *StockCodeParser) SprintSyntaxTree() string {
	var bldr strings.Builder
	p.WriteSyntaxTree(&bldr)
	return bldr.String()
}

func Pretty(pretty bool) func(*StockCodeParser) error {
	return func(p *StockCodeParser) error {
		p.Pretty = pretty
		return nil
	}
}

func Size(size int) func(*StockCodeParser) error {
	return func(p *StockCodeParser) error {
		p.tokens32 = tokens32{tree: make([]token32, 0, size)}
		return nil
	}
}
func (p *StockCodeParser) Init(options ...func(*StockCodeParser) error) error {
	var (
		max                  token32
		position, tokenIndex uint32
		buffer               []rune
	)
	for _, option := range options {
		err := option(p)
		if err != nil {
			return err
		}
	}
	p.reset = func() {
		max = token32{}
		position, tokenIndex = 0, 0

		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.tokens32
	p.parse = func(rule ...int) error {
		r := 1
		if len(rule) > 0 {
			r = rule[0]
		}
		matches := p.rules[r]()
		p.tokens32 = tree
		if matches {
			p.Trim(tokenIndex)
			return nil
		}
		return &parseError{p, max}
	}

	add := func(rule pegRule, begin uint32) {
		tree.Add(rule, begin, position, tokenIndex)
		tokenIndex++
		if begin != position && position > max.end {
			max = token32{rule, begin, position}
		}
	}

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

	/*matchChar := func(c byte) bool {
		if buffer[position] == c {
			position++
			return true
		}
		return false
	}*/

	/*matchRange := func(lower byte, upper byte) bool {
		if c := buffer[position]; c >= lower && c <= upper {
			position++
			return true
		}
		return false
	}*/

	_rules = [...]func() bool{
		nil,
		/* 0 Item <- <(Line* !.)> */
		func() bool {
			position0, tokenIndex0 := position, tokenIndex
			{
				position1 := position
			l2:
				{
					position3, tokenIndex3 := position, tokenIndex
					{
						position4 := position
						{
							position5, tokenIndex5 := position, tokenIndex
							{
								position7 := position
								if buffer[position] != rune('$') {
									goto l6
								}
								position++
								{
									position8, tokenIndex8 := position, tokenIndex
									if !_rules[ruleStockName]() {
										goto l9
									}
									goto l8
								l9:
									position, tokenIndex = position8, tokenIndex8
									if !_rules[ruleStockName]() {
										goto l6
									}
									if buffer[position] != rune('-') {
										goto l6
									}
									position++
									if !_rules[ruleLetter]() {
										goto l6
									}
								l10:
									{
										position11, tokenIndex11 := position, tokenIndex
										if !_rules[ruleLetter]() {
											goto l11
										}
										goto l10
									l11:
										position, tokenIndex = position11, tokenIndex11
									}
								}
							l8:
								if buffer[position] != rune('(') {
									goto l6
								}
								position++
								if !_rules[ruleCode]() {
									goto l6
								}
								if buffer[position] != rune('.') {
									goto l6
								}
								position++
								if !_rules[ruleMarket]() {
									goto l6
								}
								if buffer[position] != rune(')') {
									goto l6
								}
								position++
								if buffer[position] != rune('$') {
									goto l6
								}
								position++
								add(ruleFTStock, position7)
							}
							goto l5
						l6:
							position, tokenIndex = position5, tokenIndex5
							{
								position13 := position
								if buffer[position] != rune('$') {
									goto l12
								}
								position++
								if !_rules[ruleStockName]() {
									goto l12
								}
								if buffer[position] != rune('(') {
									goto l12
								}
								position++
								{
									position14, tokenIndex14 := position, tokenIndex
									if !_rules[ruleCNMarket]() {
										goto l15
									}
									if !_rules[ruleACode]() {
										goto l15
									}
									goto l14
								l15:
									position, tokenIndex = position14, tokenIndex14
									if !_rules[ruleHKMarket]() {
										goto l16
									}
									{
										position17 := position
										{
											position18, tokenIndex18 := position, tokenIndex
											if buffer[position] != rune('H') {
												goto l19
											}
											position++
											if buffer[position] != rune('S') {
												goto l19
											}
											position++
											if buffer[position] != rune('T') {
												goto l19
											}
											position++
											if buffer[position] != rune('E') {
												goto l19
											}
											position++
											if buffer[position] != rune('C') {
												goto l19
											}
											position++
											if buffer[position] != rune('H') {
												goto l19
											}
											position++
											goto l18
										l19:
											position, tokenIndex = position18, tokenIndex18
											if buffer[position] != rune('H') {
												goto l16
											}
											position++
											if buffer[position] != rune('S') {
												goto l16
											}
											position++
											if buffer[position] != rune('I') {
												goto l16
											}
											position++
										}
									l18:
										add(ruleHSCODE, position17)
									}
									goto l14
								l16:
									position, tokenIndex = position14, tokenIndex14
									if !_rules[ruleUSCode]() {
										goto l20
									}
									goto l14
								l20:
									position, tokenIndex = position14, tokenIndex14
									if !_rules[ruleHKCode]() {
										goto l21
									}
									goto l14
								l21:
									position, tokenIndex = position14, tokenIndex14
									if !matchDot() {
										goto l12
									}
									if !_rules[ruleUSCode]() {
										goto l12
									}
								}
							l14:
								if buffer[position] != rune(')') {
									goto l12
								}
								position++
								if buffer[position] != rune('$') {
									goto l12
								}
								position++
								add(ruleXLStock, position13)
							}
							goto l5
						l12:
							position, tokenIndex = position5, tokenIndex5
							{
								position23 := position
								{
									position24, tokenIndex24 := position, tokenIndex
									if buffer[position] != rune('$') {
										goto l25
									}
									position++
									if !_rules[ruleCode]() {
										goto l25
									}
									{
										position26, tokenIndex26 := position, tokenIndex
										if !_rules[ruleSuffix]() {
											goto l27
										}
										goto l26
									l27:
										position, tokenIndex = position26, tokenIndex26
										{
											position28, tokenIndex28 := position, tokenIndex
											if !_rules[ruleSuffix]() {
												goto l28
											}
											goto l29
										l28:
											position, tokenIndex = position28, tokenIndex28
										}
									l29:
									}
								l26:
									if buffer[position] != rune('$') {
										goto l25
									}
									position++
									goto l24
								l25:
									position, tokenIndex = position24, tokenIndex24
									if buffer[position] != rune('$') {
										goto l30
									}
									position++
									if !_rules[ruleCode]() {
										goto l30
									}
									if !_rules[ruleSuffix]() {
										goto l30
									}
									goto l24
								l30:
									position, tokenIndex = position24, tokenIndex24
									if buffer[position] != rune('(') {
										goto l31
									}
									position++
									{
										position32, tokenIndex32 := position, tokenIndex
										if buffer[position] != rune('N') {
											goto l33
										}
										position++
										if buffer[position] != rune('Y') {
											goto l33
										}
										position++
										if buffer[position] != rune('S') {
											goto l33
										}
										position++
										if buffer[position] != rune('E') {
											goto l33
										}
										position++
										goto l32
									l33:
										position, tokenIndex = position32, tokenIndex32
										if buffer[position] != rune('N') {
											goto l31
										}
										position++
										if buffer[position] != rune('A') {
											goto l31
										}
										position++
										if buffer[position] != rune('S') {
											goto l31
										}
										position++
										if buffer[position] != rune('D') {
											goto l31
										}
										position++
										if buffer[position] != rune('A') {
											goto l31
										}
										position++
										if buffer[position] != rune('Q') {
											goto l31
										}
										position++
									}
								l32:
									{
										position34, tokenIndex34 := position, tokenIndex
										if buffer[position] != rune('：') {
											goto l35
										}
										position++
										goto l34
									l35:
										position, tokenIndex = position34, tokenIndex34
										if buffer[position] != rune(':') {
											goto l31
										}
										position++
									}
								l34:
								l36:
									{
										position37, tokenIndex37 := position, tokenIndex
										{
											position38 := position
											{
												position39, tokenIndex39 := position, tokenIndex
												if buffer[position] != rune(' ') {
													goto l40
												}
												position++
												goto l39
											l40:
												position, tokenIndex = position39, tokenIndex39
												if buffer[position] != rune('\t') {
													goto l37
												}
												position++
											}
										l39:
											add(ruleSP, position38)
										}
										goto l36
									l37:
										position, tokenIndex = position37, tokenIndex37
									}
									if !_rules[ruleUSCode]() {
										goto l31
									}
									if buffer[position] != rune(')') {
										goto l31
									}
									position++
									goto l24
								l31:
									position, tokenIndex = position24, tokenIndex24
									{
										switch buffer[position] {
										case '(':
											if buffer[position] != rune('(') {
												goto l22
											}
											position++
											if !_rules[ruleMarket]() {
												goto l22
											}
											if buffer[position] != rune(':') {
												goto l22
											}
											position++
											if !_rules[ruleCode]() {
												goto l22
											}
											if buffer[position] != rune(')') {
												goto l22
											}
											position++
										case '$':
											if buffer[position] != rune('$') {
												goto l22
											}
											position++
											if !_rules[ruleUSCode]() {
												goto l22
											}
										default:
											if buffer[position] != rune(' ') {
												goto l22
											}
											position++
										l42:
											{
												position43, tokenIndex43 := position, tokenIndex
												if buffer[position] != rune(' ') {
													goto l43
												}
												position++
												goto l42
											l43:
												position, tokenIndex = position43, tokenIndex43
											}
											if !_rules[ruleCode]() {
												goto l22
											}
											if !_rules[ruleSuffix]() {
												goto l22
											}
										}
									}

								}
							l24:
								add(ruleStock, position23)
							}
							goto l5
						l22:
							position, tokenIndex = position5, tokenIndex5
							{
								position44 := position
								if !matchDot() {
									goto l3
								}
								add(ruleOTHER, position44)
							}
						}
					l5:
						add(ruleLine, position4)
					}
					goto l2
				l3:
					position, tokenIndex = position3, tokenIndex3
				}
				{
					position45, tokenIndex45 := position, tokenIndex
					if !matchDot() {
						goto l45
					}
					goto l0
				l45:
					position, tokenIndex = position45, tokenIndex45
				}
				add(ruleItem, position1)
			}
			return true
		l0:
			position, tokenIndex = position0, tokenIndex0
			return false
		},
		/* 1 Line <- <(FTStock / XLStock / Stock / OTHER)> */
		nil,
		/* 2 OTHER <- <.> */
		nil,
		/* 3 Stock <- <(('$' Code (Suffix / Suffix?) '$') / ('$' Code Suffix) / ('(' (('N' 'Y' 'S' 'E') / ('N' 'A' 'S' 'D' 'A' 'Q')) ('：' / ':') SP* USCode ')') / ((&('(') ('(' Market ':' Code ')')) | (&('$') ('$' USCode)) | (&(' ') (' '+ Code Suffix))))> */
		nil,
		/* 4 XLStock <- <('$' StockName '(' ((CNMarket ACode) / (HKMarket HSCODE) / USCode / HKCode / (. USCode)) ')' '$')> */
		nil,
		/* 5 FTStock <- <('$' (StockName / (StockName '-' Letter+)) '(' Code '.' Market ')' '$')> */
		nil,
		/* 6 StockName <- <(!('"' / ((&('"') '"') | (&(')') ')') | (&('(') '('))) .)*> */
		func() bool {
			{
				position52 := position
			l53:
				{
					position54, tokenIndex54 := position, tokenIndex
					{
						position55, tokenIndex55 := position, tokenIndex
						{
							position56, tokenIndex56 := position, tokenIndex
							if buffer[position] != rune('"') {
								goto l57
							}
							position++
							goto l56
						l57:
							position, tokenIndex = position56, tokenIndex56
							{
								switch buffer[position] {
								case '"':
									if buffer[position] != rune('"') {
										goto l55
									}
									position++
								case ')':
									if buffer[position] != rune(')') {
										goto l55
									}
									position++
								default:
									if buffer[position] != rune('(') {
										goto l55
									}
									position++
								}
							}

						}
					l56:
						goto l54
					l55:
						position, tokenIndex = position55, tokenIndex55
					}
					if !matchDot() {
						goto l54
					}
					goto l53
				l54:
					position, tokenIndex = position54, tokenIndex54
				}
				add(ruleStockName, position52)
			}
			return true
		},
		/* 7 Code <- <(USCode / HKCode / ACode)> */
		func() bool {
			position59, tokenIndex59 := position, tokenIndex
			{
				position60 := position
				{
					position61, tokenIndex61 := position, tokenIndex
					if !_rules[ruleUSCode]() {
						goto l62
					}
					goto l61
				l62:
					position, tokenIndex = position61, tokenIndex61
					if !_rules[ruleHKCode]() {
						goto l63
					}
					goto l61
				l63:
					position, tokenIndex = position61, tokenIndex61
					if !_rules[ruleACode]() {
						goto l59
					}
				}
			l61:
				add(ruleCode, position60)
			}
			return true
		l59:
			position, tokenIndex = position59, tokenIndex59
			return false
		},
		/* 8 USCode <- <('.'? Letter+)> */
		func() bool {
			position64, tokenIndex64 := position, tokenIndex
			{
				position65 := position
				{
					position66, tokenIndex66 := position, tokenIndex
					if buffer[position] != rune('.') {
						goto l66
					}
					position++
					goto l67
				l66:
					position, tokenIndex = position66, tokenIndex66
				}
			l67:
				if !_rules[ruleLetter]() {
					goto l64
				}
			l68:
				{
					position69, tokenIndex69 := position, tokenIndex
					if !_rules[ruleLetter]() {
						goto l69
					}
					goto l68
				l69:
					position, tokenIndex = position69, tokenIndex69
				}
				add(ruleUSCode, position65)
			}
			return true
		l64:
			position, tokenIndex = position64, tokenIndex64
			return false
		},
		/* 9 HKCode <- <Number+> */
		func() bool {
			position70, tokenIndex70 := position, tokenIndex
			{
				position71 := position
				if !_rules[ruleNumber]() {
					goto l70
				}
			l72:
				{
					position73, tokenIndex73 := position, tokenIndex
					if !_rules[ruleNumber]() {
						goto l73
					}
					goto l72
				l73:
					position, tokenIndex = position73, tokenIndex73
				}
				add(ruleHKCode, position71)
			}
			return true
		l70:
			position, tokenIndex = position70, tokenIndex70
			return false
		},
		/* 10 ACode <- <Number+> */
		func() bool {
			position74, tokenIndex74 := position, tokenIndex
			{
				position75 := position
				if !_rules[ruleNumber]() {
					goto l74
				}
			l76:
				{
					position77, tokenIndex77 := position, tokenIndex
					if !_rules[ruleNumber]() {
						goto l77
					}
					goto l76
				l77:
					position, tokenIndex = position77, tokenIndex77
				}
				add(ruleACode, position75)
			}
			return true
		l74:
			position, tokenIndex = position74, tokenIndex74
			return false
		},
		/* 11 HSCODE <- <(('H' 'S' 'T' 'E' 'C' 'H') / ('H' 'S' 'I'))> */
		nil,
		/* 12 Letter <- <[A-Z]> */
		func() bool {
			position79, tokenIndex79 := position, tokenIndex
			{
				position80 := position
				if c := buffer[position]; c < rune('A') || c > rune('Z') {
					goto l79
				}
				position++
				add(ruleLetter, position80)
			}
			return true
		l79:
			position, tokenIndex = position79, tokenIndex79
			return false
		},
		/* 13 Number <- <[0-9]> */
		func() bool {
			position81, tokenIndex81 := position, tokenIndex
			{
				position82 := position
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l81
				}
				position++
				add(ruleNumber, position82)
			}
			return true
		l81:
			position, tokenIndex = position81, tokenIndex81
			return false
		},
		/* 14 Suffix <- <('.' (Market / ('o' / 'O')))> */
		func() bool {
			position83, tokenIndex83 := position, tokenIndex
			{
				position84 := position
				if buffer[position] != rune('.') {
					goto l83
				}
				position++
				{
					position85, tokenIndex85 := position, tokenIndex
					if !_rules[ruleMarket]() {
						goto l86
					}
					goto l85
				l86:
					position, tokenIndex = position85, tokenIndex85
					{
						position87, tokenIndex87 := position, tokenIndex
						if buffer[position] != rune('o') {
							goto l88
						}
						position++
						goto l87
					l88:
						position, tokenIndex = position87, tokenIndex87
						if buffer[position] != rune('O') {
							goto l83
						}
						position++
					}
				l87:
				}
			l85:
				add(ruleSuffix, position84)
			}
			return true
		l83:
			position, tokenIndex = position83, tokenIndex83
			return false
		},
		/* 15 Market <- <(CNMarket / ((&('S') SGMarket) | (&('U') USMarket) | (&('H') HKMarket)))> */
		func() bool {
			position89, tokenIndex89 := position, tokenIndex
			{
				position90 := position
				{
					position91, tokenIndex91 := position, tokenIndex
					if !_rules[ruleCNMarket]() {
						goto l92
					}
					goto l91
				l92:
					position, tokenIndex = position91, tokenIndex91
					{
						switch buffer[position] {
						case 'S':
							{
								position94 := position
								if buffer[position] != rune('S') {
									goto l89
								}
								position++
								if buffer[position] != rune('G') {
									goto l89
								}
								position++
								add(ruleSGMarket, position94)
							}
						case 'U':
							{
								position95 := position
								if buffer[position] != rune('U') {
									goto l89
								}
								position++
								if buffer[position] != rune('S') {
									goto l89
								}
								position++
								add(ruleUSMarket, position95)
							}
						default:
							if !_rules[ruleHKMarket]() {
								goto l89
							}
						}
					}

				}
			l91:
				add(ruleMarket, position90)
			}
			return true
		l89:
			position, tokenIndex = position89, tokenIndex89
			return false
		},
		/* 16 CNMarket <- <(('S' 'H') / ('S' 'Z'))> */
		func() bool {
			position96, tokenIndex96 := position, tokenIndex
			{
				position97 := position
				{
					position98, tokenIndex98 := position, tokenIndex
					if buffer[position] != rune('S') {
						goto l99
					}
					position++
					if buffer[position] != rune('H') {
						goto l99
					}
					position++
					goto l98
				l99:
					position, tokenIndex = position98, tokenIndex98
					if buffer[position] != rune('S') {
						goto l96
					}
					position++
					if buffer[position] != rune('Z') {
						goto l96
					}
					position++
				}
			l98:
				add(ruleCNMarket, position97)
			}
			return true
		l96:
			position, tokenIndex = position96, tokenIndex96
			return false
		},
		/* 17 HKMarket <- <('H' 'K')> */
		func() bool {
			position100, tokenIndex100 := position, tokenIndex
			{
				position101 := position
				if buffer[position] != rune('H') {
					goto l100
				}
				position++
				if buffer[position] != rune('K') {
					goto l100
				}
				position++
				add(ruleHKMarket, position101)
			}
			return true
		l100:
			position, tokenIndex = position100, tokenIndex100
			return false
		},
		/* 18 USMarket <- <('U' 'S')> */
		nil,
		/* 19 SGMarket <- <('S' 'G')> */
		nil,
		/* 20 SP <- <(' ' / '\t')> */
		nil,
	}
	p.rules = _rules
	return nil
}