cmd/geth: add --config file flag (#13875)

* p2p/discover, p2p/discv5: add marshaling methods to Node

* p2p/netutil: make Netlist decodable from TOML

* common/math: encode nil HexOrDecimal256 as 0x0

* cmd/geth: add --config file flag

* cmd/geth: add missing license header

* eth: prettify Config again, fix tests

* eth: use gasprice.Config instead of duplicating its fields

* eth/gasprice: hide nil default from dumpconfig output

* cmd/geth: hide genesis block in dumpconfig output

* node: make tests compile

* console: fix tests

* cmd/geth: make TOML keys look exactly like Go struct fields

* p2p: use discovery by default

This makes the zero Config slightly more useful. It also fixes package
node tests because Node detects reuse of the datadir through the
NodeDatabase.

* cmd/geth: make ethstats URL settable through config file

* cmd/faucet: fix configuration

* cmd/geth: dedup attach tests

* eth: add comment for DefaultConfig

* eth: pass downloader.SyncMode in Config

This removes the FastSync, LightSync flags in favour of a more
general SyncMode flag.

* cmd/utils: remove jitvm flags

* cmd/utils: make mutually exclusive flag error prettier

It now reads:

   Fatal: flags --dev, --testnet can't be used at the same time

* p2p: fix typo

* node: add DefaultConfig, use it for geth

* mobile: add missing NoDiscovery option

* cmd/utils: drop MakeNode

This exposed a couple of places that needed to be updated to use
node.DefaultConfig.

* node: fix typo

* eth: make fast sync the default mode

* cmd/utils: remove IPCApiFlag (unused)

* node: remove default IPC path

Set it in the frontends instead.

* cmd/geth: add --syncmode

* cmd/utils: make --ipcdisable and --ipcpath mutually exclusive

* cmd/utils: don't enable WS, HTTP when setting addr

* cmd/utils: fix --identity

1 files changed, 2556 insertions, 0 deletions

diff --git a/vendor/github.com/naoina/toml/parse.peg.go b/vendor/github.com/naoina/toml/parse.peg.go
new file mode 100644
index 000000000..d7de73b19
--- /dev/null
+++ b/vendor/github.com/naoina/toml/parse.peg.go
@@ -0,0 +1,2556 @@
+package toml
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strconv"
+)
+
+const endSymbol rune = 1114112
+
+/* The rule types inferred from the grammar are below. */
+type pegRule uint8
+
+const (
+	ruleUnknown pegRule = iota
+	ruleTOML
+	ruleExpression
+	rulenewline
+	rulews
+	rulewsnl
+	rulecomment
+	rulekeyval
+	rulekey
+	rulebareKey
+	rulequotedKey
+	ruleval
+	ruletable
+	rulestdTable
+	rulearrayTable
+	ruleinlineTable
+	ruleinlineTableKeyValues
+	ruletableKey
+	ruletableKeySep
+	ruleinlineTableValSep
+	ruleinteger
+	ruleint
+	rulefloat
+	rulefrac
+	ruleexp
+	rulestring
+	rulebasicString
+	rulebasicChar
+	ruleescaped
+	rulebasicUnescaped
+	ruleescape
+	rulemlBasicString
+	rulemlBasicBody
+	ruleliteralString
+	ruleliteralChar
+	rulemlLiteralString
+	rulemlLiteralBody
+	rulemlLiteralChar
+	rulehexdigit
+	rulehexQuad
+	ruleboolean
+	ruledateFullYear
+	ruledateMonth
+	ruledateMDay
+	ruletimeHour
+	ruletimeMinute
+	ruletimeSecond
+	ruletimeSecfrac
+	ruletimeNumoffset
+	ruletimeOffset
+	rulepartialTime
+	rulefullDate
+	rulefullTime
+	ruledatetime
+	ruledigit
+	ruledigitDual
+	ruledigitQuad
+	rulearray
+	rulearrayValues
+	rulearraySep
+	ruleAction0
+	rulePegText
+	ruleAction1
+	ruleAction2
+	ruleAction3
+	ruleAction4
+	ruleAction5
+	ruleAction6
+	ruleAction7
+	ruleAction8
+	ruleAction9
+	ruleAction10
+	ruleAction11
+	ruleAction12
+	ruleAction13
+	ruleAction14
+	ruleAction15
+	ruleAction16
+	ruleAction17
+	ruleAction18
+	ruleAction19
+	ruleAction20
+	ruleAction21
+	ruleAction22
+	ruleAction23
+	ruleAction24
+)
+
+var rul3s = [...]string{
+	"Unknown",
+	"TOML",
+	"Expression",
+	"newline",
+	"ws",
+	"wsnl",
+	"comment",
+	"keyval",
+	"key",
+	"bareKey",
+	"quotedKey",
+	"val",
+	"table",
+	"stdTable",
+	"arrayTable",
+	"inlineTable",
+	"inlineTableKeyValues",
+	"tableKey",
+	"tableKeySep",
+	"inlineTableValSep",
+	"integer",
+	"int",
+	"float",
+	"frac",
+	"exp",
+	"string",
+	"basicString",
+	"basicChar",
+	"escaped",
+	"basicUnescaped",
+	"escape",
+	"mlBasicString",
+	"mlBasicBody",
+	"literalString",
+	"literalChar",
+	"mlLiteralString",
+	"mlLiteralBody",
+	"mlLiteralChar",
+	"hexdigit",
+	"hexQuad",
+	"boolean",
+	"dateFullYear",
+	"dateMonth",
+	"dateMDay",
+	"timeHour",
+	"timeMinute",
+	"timeSecond",
+	"timeSecfrac",
+	"timeNumoffset",
+	"timeOffset",
+	"partialTime",
+	"fullDate",
+	"fullTime",
+	"datetime",
+	"digit",
+	"digitDual",
+	"digitQuad",
+	"array",
+	"arrayValues",
+	"arraySep",
+	"Action0",
+	"PegText",
+	"Action1",
+	"Action2",
+	"Action3",
+	"Action4",
+	"Action5",
+	"Action6",
+	"Action7",
+	"Action8",
+	"Action9",
+	"Action10",
+	"Action11",
+	"Action12",
+	"Action13",
+	"Action14",
+	"Action15",
+	"Action16",
+	"Action17",
+	"Action18",
+	"Action19",
+	"Action20",
+	"Action21",
+	"Action22",
+	"Action23",
+	"Action24",
+}
+
+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(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.Printf(" ")
+			}
+			rule := rul3s[node.pegRule]
+			quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
+			if !pretty {
+				fmt.Printf("%v %v\n", rule, quote)
+			} else {
+				fmt.Printf("\x1B[34m%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(buffer string) {
+	node.print(false, buffer)
+}
+
+func (node *node32) PrettyPrint(buffer string) {
+	node.print(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(buffer)
+}
+
+func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
+	t.AST().PrettyPrint(buffer)
+}
+
+func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
+	if tree := t.tree; int(index) >= len(tree) {
+		expanded := make([]token32, 2*len(tree))
+		copy(expanded, tree)
+		t.tree = expanded
+	}
+	t.tree[index] = token32{
+		pegRule: rule,
+		begin:   begin,
+		end:     end,
+	}
+}
+
+func (t *tokens32) Tokens() []token32 {
+	return t.tree
+}
+
+type tomlParser struct {
+	toml
+
+	Buffer string
+	buffer []rune
+	rules  [86]func() bool
+	parse  func(rule ...int) error
+	reset  func()
+	Pretty bool
+	tokens32
+}
+
+func (p *tomlParser) Parse(rule ...int) error {
+	return p.parse(rule...)
+}
+
+func (p *tomlParser) 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   *tomlParser
+	max token32
+}
+
+func (e *parseError) Error() string {
+	tokens, error := []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)
+		error += 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 error
+}
+
+func (p *tomlParser) PrintSyntaxTree() {
+	if p.Pretty {
+		p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
+	} else {
+		p.tokens32.PrintSyntaxTree(p.Buffer)
+	}
+}
+
+func (p *tomlParser) Execute() {
+	buffer, _buffer, text, begin, end := p.Buffer, p.buffer, "", 0, 0
+	for _, token := range p.Tokens() {
+		switch token.pegRule {
+
+		case rulePegText:
+			begin, end = int(token.begin), int(token.end)
+			text = string(_buffer[begin:end])
+
+		case ruleAction0:
+			_ = buffer
+		case ruleAction1:
+			p.SetTableString(begin, end)
+		case ruleAction2:
+			p.AddLineCount(end - begin)
+		case ruleAction3:
+			p.AddLineCount(end - begin)
+		case ruleAction4:
+			p.AddKeyValue()
+		case ruleAction5:
+			p.SetKey(p.buffer, begin, end)
+		case ruleAction6:
+			p.SetKey(p.buffer, begin-1, end+1)
+		case ruleAction7:
+			p.SetTime(begin, end)
+		case ruleAction8:
+			p.SetFloat64(begin, end)
+		case ruleAction9:
+			p.SetInt64(begin, end)
+		case ruleAction10:
+			p.SetString(begin, end)
+		case ruleAction11:
+			p.SetBool(begin, end)
+		case ruleAction12:
+			p.SetArray(begin, end)
+		case ruleAction13:
+			p.SetTable(p.buffer, begin, end)
+		case ruleAction14:
+			p.SetArrayTable(p.buffer, begin, end)
+		case ruleAction15:
+			p.StartInlineTable()
+		case ruleAction16:
+			p.EndInlineTable()
+		case ruleAction17:
+			p.SetBasicString(p.buffer, begin, end)
+		case ruleAction18:
+			p.SetMultilineString()
+		case ruleAction19:
+			p.AddMultilineBasicBody(p.buffer, begin, end)
+		case ruleAction20:
+			p.SetLiteralString(p.buffer, begin, end)
+		case ruleAction21:
+			p.SetMultilineLiteralString(p.buffer, begin, end)
+		case ruleAction22:
+			p.StartArray()
+		case ruleAction23:
+			p.AddArrayVal()
+		case ruleAction24:
+			p.AddArrayVal()
+
+		}
+	}
+	_, _, _, _, _ = buffer, _buffer, text, begin, end
+}
+
+func (p *tomlParser) Init() {
+	var (
+		max                  token32
+		position, tokenIndex uint32
+		buffer               []rune
+	)
+	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 := tokens32{tree: make([]token32, math.MaxInt16)}
+	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 TOML <- <(Expression (newline Expression)* newline? !. Action0)> */
+		func() bool {
+			position0, tokenIndex0 := position, tokenIndex
+			{
+				position1 := position
+				if !_rules[ruleExpression]() {
+					goto l0
+				}
+			l2:
+				{
+					position3, tokenIndex3 := position, tokenIndex
+					if !_rules[rulenewline]() {
+						goto l3
+					}
+					if !_rules[ruleExpression]() {
+						goto l3
+					}
+					goto l2
+				l3:
+					position, tokenIndex = position3, tokenIndex3
+				}
+				{
+					position4, tokenIndex4 := position, tokenIndex
+					if !_rules[rulenewline]() {
+						goto l4
+					}
+					goto l5
+				l4:
+					position, tokenIndex = position4, tokenIndex4
+				}
+			l5:
+				{
+					position6, tokenIndex6 := position, tokenIndex
+					if !matchDot() {
+						goto l6
+					}
+					goto l0
+				l6:
+					position, tokenIndex = position6, tokenIndex6
+				}
+				{
+					add(ruleAction0, position)
+				}
+				add(ruleTOML, position1)
+			}
+			return true
+		l0:
+			position, tokenIndex = position0, tokenIndex0
+			return false
+		},
+		/* 1 Expression <- <((<(ws table ws comment? (wsnl keyval ws comment?)*)> Action1) / (ws keyval ws comment?) / (ws comment?) / ws)> */
+		func() bool {
+			position8, tokenIndex8 := position, tokenIndex
+			{
+				position9 := position
+				{
+					position10, tokenIndex10 := position, tokenIndex
+					{
+						position12 := position
+						if !_rules[rulews]() {
+							goto l11
+						}
+						{
+							position13 := position
+							{
+								position14, tokenIndex14 := position, tokenIndex
+								{
+									position16 := position
+									if buffer[position] != rune('[') {
+										goto l15
+									}
+									position++
+									if !_rules[rulews]() {
+										goto l15
+									}
+									{
+										position17 := position
+										if !_rules[ruletableKey]() {
+											goto l15
+										}
+										add(rulePegText, position17)
+									}
+									if !_rules[rulews]() {
+										goto l15
+									}
+									if buffer[position] != rune(']') {
+										goto l15
+									}
+									position++
+									{
+										add(ruleAction13, position)
+									}
+									add(rulestdTable, position16)
+								}
+								goto l14
+							l15:
+								position, tokenIndex = position14, tokenIndex14
+								{
+									position19 := position
+									if buffer[position] != rune('[') {
+										goto l11
+									}
+									position++
+									if buffer[position] != rune('[') {
+										goto l11
+									}
+									position++
+									if !_rules[rulews]() {
+										goto l11
+									}
+									{
+										position20 := position
+										if !_rules[ruletableKey]() {
+											goto l11
+										}
+										add(rulePegText, position20)
+									}
+									if !_rules[rulews]() {
+										goto l11
+									}
+									if buffer[position] != rune(']') {
+										goto l11
+									}
+									position++
+									if buffer[position] != rune(']') {
+										goto l11
+									}
+									position++
+									{
+										add(ruleAction14, position)
+									}
+									add(rulearrayTable, position19)
+								}
+							}
+						l14:
+							add(ruletable, position13)
+						}
+						if !_rules[rulews]() {
+							goto l11
+						}
+						{
+							position22, tokenIndex22 := position, tokenIndex
+							if !_rules[rulecomment]() {
+								goto l22
+							}
+							goto l23
+						l22:
+							position, tokenIndex = position22, tokenIndex22
+						}
+					l23:
+					l24:
+						{
+							position25, tokenIndex25 := position, tokenIndex
+							if !_rules[rulewsnl]() {
+								goto l25
+							}
+							if !_rules[rulekeyval]() {
+								goto l25
+							}
+							if !_rules[rulews]() {
+								goto l25
+							}
+							{
+								position26, tokenIndex26 := position, tokenIndex
+								if !_rules[rulecomment]() {
+									goto l26
+								}
+								goto l27
+							l26:
+								position, tokenIndex = position26, tokenIndex26
+							}
+						l27:
+							goto l24
+						l25:
+							position, tokenIndex = position25, tokenIndex25
+						}
+						add(rulePegText, position12)
+					}
+					{
+						add(ruleAction1, position)
+					}
+					goto l10
+				l11:
+					position, tokenIndex = position10, tokenIndex10
+					if !_rules[rulews]() {
+						goto l29
+					}
+					if !_rules[rulekeyval]() {
+						goto l29
+					}
+					if !_rules[rulews]() {
+						goto l29
+					}
+					{
+						position30, tokenIndex30 := position, tokenIndex
+						if !_rules[rulecomment]() {
+							goto l30
+						}
+						goto l31
+					l30:
+						position, tokenIndex = position30, tokenIndex30
+					}
+				l31:
+					goto l10
+				l29:
+					position, tokenIndex = position10, tokenIndex10
+					if !_rules[rulews]() {
+						goto l32
+					}
+					{
+						position33, tokenIndex33 := position, tokenIndex
+						if !_rules[rulecomment]() {
+							goto l33
+						}
+						goto l34
+					l33:
+						position, tokenIndex = position33, tokenIndex33
+					}
+				l34:
+					goto l10
+				l32:
+					position, tokenIndex = position10, tokenIndex10
+					if !_rules[rulews]() {
+						goto l8
+					}
+				}
+			l10:
+				add(ruleExpression, position9)
+			}
+			return true
+		l8:
+			position, tokenIndex = position8, tokenIndex8
+			return false
+		},
+		/* 2 newline <- <(<('\r' / '\n')+> Action2)> */
+		func() bool {
+			position35, tokenIndex35 := position, tokenIndex
+			{
+				position36 := position
+				{
+					position37 := position
+					{
+						position40, tokenIndex40 := position, tokenIndex
+						if buffer[position] != rune('\r') {
+							goto l41
+						}
+						position++
+						goto l40
+					l41:
+						position, tokenIndex = position40, tokenIndex40
+						if buffer[position] != rune('\n') {
+							goto l35
+						}
+						position++
+					}
+				l40:
+				l38:
+					{
+						position39, tokenIndex39 := position, tokenIndex
+						{
+							position42, tokenIndex42 := position, tokenIndex
+							if buffer[position] != rune('\r') {
+								goto l43
+							}
+							position++
+							goto l42
+						l43:
+							position, tokenIndex = position42, tokenIndex42
+							if buffer[position] != rune('\n') {
+								goto l39
+							}
+							position++
+						}
+					l42:
+						goto l38
+					l39:
+						position, tokenIndex = position39, tokenIndex39
+					}
+					add(rulePegText, position37)
+				}
+				{
+					add(ruleAction2, position)
+				}
+				add(rulenewline, position36)
+			}
+			return true
+		l35:
+			position, tokenIndex = position35, tokenIndex35
+			return false
+		},
+		/* 3 ws <- <(' ' / '\t')*> */
+		func() bool {
+			{
+				position46 := position
+			l47:
+				{
+					position48, tokenIndex48 := position, tokenIndex
+					{
+						position49, tokenIndex49 := position, tokenIndex
+						if buffer[position] != rune(' ') {
+							goto l50
+						}
+						position++
+						goto l49
+					l50:
+						position, tokenIndex = position49, tokenIndex49
+						if buffer[position] != rune('\t') {
+							goto l48
+						}
+						position++
+					}
+				l49:
+					goto l47
+				l48:
+					position, tokenIndex = position48, tokenIndex48
+				}
+				add(rulews, position46)
+			}
+			return true
+		},
+		/* 4 wsnl <- <((&('\t') '\t') | (&(' ') ' ') | (&('\n' | '\r') (<('\r' / '\n')> Action3)))*> */
+		func() bool {
+			{
+				position52 := position
+			l53:
+				{
+					position54, tokenIndex54 := position, tokenIndex
+					{
+						switch buffer[position] {
+						case '\t':
+							if buffer[position] != rune('\t') {
+								goto l54
+							}
+							position++
+							break
+						case ' ':
+							if buffer[position] != rune(' ') {
+								goto l54
+							}
+							position++
+							break
+						default:
+							{
+								position56 := position
+								{
+									position57, tokenIndex57 := position, tokenIndex
+									if buffer[position] != rune('\r') {
+										goto l58
+									}
+									position++
+									goto l57
+								l58:
+									position, tokenIndex = position57, tokenIndex57
+									if buffer[position] != rune('\n') {
+										goto l54
+									}
+									position++
+								}
+							l57:
+								add(rulePegText, position56)
+							}
+							{
+								add(ruleAction3, position)
+							}
+							break
+						}
+					}
+
+					goto l53
+				l54:
+					position, tokenIndex = position54, tokenIndex54
+				}
+				add(rulewsnl, position52)
+			}
+			return true
+		},
+		/* 5 comment <- <('#' <('\t' / [ -\U0010ffff])*>)> */
+		func() bool {
+			position60, tokenIndex60 := position, tokenIndex
+			{
+				position61 := position
+				if buffer[position] != rune('#') {
+					goto l60
+				}
+				position++
+				{
+					position62 := position
+				l63:
+					{
+						position64, tokenIndex64 := position, tokenIndex
+						{
+							position65, tokenIndex65 := position, tokenIndex
+							if buffer[position] != rune('\t') {
+								goto l66
+							}
+							position++
+							goto l65
+						l66:
+							position, tokenIndex = position65, tokenIndex65
+							if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
+								goto l64
+							}
+							position++
+						}
+					l65:
+						goto l63
+					l64:
+						position, tokenIndex = position64, tokenIndex64
+					}
+					add(rulePegText, position62)
+				}
+				add(rulecomment, position61)
+			}
+			return true
+		l60:
+			position, tokenIndex = position60, tokenIndex60
+			return false
+		},
+		/* 6 keyval <- <(key ws '=' ws val Action4)> */
+		func() bool {
+			position67, tokenIndex67 := position, tokenIndex
+			{
+				position68 := position
+				if !_rules[rulekey]() {
+					goto l67
+				}
+				if !_rules[rulews]() {
+					goto l67
+				}
+				if buffer[position] != rune('=') {
+					goto l67
+				}
+				position++
+				if !_rules[rulews]() {
+					goto l67
+				}
+				if !_rules[ruleval]() {
+					goto l67
+				}
+				{
+					add(ruleAction4, position)
+				}
+				add(rulekeyval, position68)
+			}
+			return true
+		l67:
+			position, tokenIndex = position67, tokenIndex67
+			return false
+		},
+		/* 7 key <- <(bareKey / quotedKey)> */
+		func() bool {
+			position70, tokenIndex70 := position, tokenIndex
+			{
+				position71 := position
+				{
+					position72, tokenIndex72 := position, tokenIndex
+					{
+						position74 := position
+						{
+							position75 := position
+							{
+								switch buffer[position] {
+								case '_':
+									if buffer[position] != rune('_') {
+										goto l73
+									}
+									position++
+									break
+								case '-':
+									if buffer[position] != rune('-') {
+										goto l73
+									}
+									position++
+									break
+								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':
+									if c := buffer[position]; c < rune('a') || c > rune('z') {
+										goto l73
+									}
+									position++
+									break
+								case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+									if c := buffer[position]; c < rune('0') || c > rune('9') {
+										goto l73
+									}
+									position++
+									break
+								default:
+									if c := buffer[position]; c < rune('A') || c > rune('Z') {
+										goto l73
+									}
+									position++
+									break
+								}
+							}
+
+						l76:
+							{
+								position77, tokenIndex77 := position, tokenIndex
+								{
+									switch buffer[position] {
+									case '_':
+										if buffer[position] != rune('_') {
+											goto l77
+										}
+										position++
+										break
+									case '-':
+										if buffer[position] != rune('-') {
+											goto l77
+										}
+										position++
+										break
+									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':
+										if c := buffer[position]; c < rune('a') || c > rune('z') {
+											goto l77
+										}
+										position++
+										break
+									case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+										if c := buffer[position]; c < rune('0') || c > rune('9') {
+											goto l77
+										}
+										position++
+										break
+									default:
+										if c := buffer[position]; c < rune('A') || c > rune('Z') {
+											goto l77
+										}
+										position++
+										break
+									}
+								}
+
+								goto l76
+							l77:
+								position, tokenIndex = position77, tokenIndex77
+							}
+							add(rulePegText, position75)
+						}
+						{
+							add(ruleAction5, position)
+						}
+						add(rulebareKey, position74)
+					}
+					goto l72
+				l73:
+					position, tokenIndex = position72, tokenIndex72
+					{
+						position81 := position
+						if buffer[position] != rune('"') {
+							goto l70
+						}
+						position++
+						{
+							position82 := position
+							if !_rules[rulebasicChar]() {
+								goto l70
+							}
+						l83:
+							{
+								position84, tokenIndex84 := position, tokenIndex
+								if !_rules[rulebasicChar]() {
+									goto l84
+								}
+								goto l83
+							l84:
+								position, tokenIndex = position84, tokenIndex84
+							}
+							add(rulePegText, position82)
+						}
+						if buffer[position] != rune('"') {
+							goto l70
+						}
+						position++
+						{
+							add(ruleAction6, position)
+						}
+						add(rulequotedKey, position81)
+					}
+				}
+			l72:
+				add(rulekey, position71)
+			}
+			return true
+		l70:
+			position, tokenIndex = position70, tokenIndex70
+			return false
+		},
+		/* 8 bareKey <- <(<((&('_') '_') | (&('-') '-') | (&('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]))+> Action5)> */
+		nil,
+		/* 9 quotedKey <- <('"' <basicChar+> '"' Action6)> */
+		nil,
+		/* 10 val <- <((<datetime> Action7) / (<float> Action8) / ((&('{') inlineTable) | (&('[') (<array> Action12)) | (&('f' | 't') (<boolean> Action11)) | (&('"' | '\'') (<string> Action10)) | (&('+' | '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') (<integer> Action9))))> */
+		func() bool {
+			position88, tokenIndex88 := position, tokenIndex
+			{
+				position89 := position
+				{
+					position90, tokenIndex90 := position, tokenIndex
+					{
+						position92 := position
+						{
+							position93 := position
+							{
+								position94, tokenIndex94 := position, tokenIndex
+								{
+									position96 := position
+									{
+										position97 := position
+										{
+											position98 := position
+											if !_rules[ruledigitDual]() {
+												goto l95
+											}
+											if !_rules[ruledigitDual]() {
+												goto l95
+											}
+											add(ruledigitQuad, position98)
+										}
+										add(ruledateFullYear, position97)
+									}
+									if buffer[position] != rune('-') {
+										goto l95
+									}
+									position++
+									{
+										position99 := position
+										if !_rules[ruledigitDual]() {
+											goto l95
+										}
+										add(ruledateMonth, position99)
+									}
+									if buffer[position] != rune('-') {
+										goto l95
+									}
+									position++
+									{
+										position100 := position
+										if !_rules[ruledigitDual]() {
+											goto l95
+										}
+										add(ruledateMDay, position100)
+									}
+									add(rulefullDate, position96)
+								}
+								{
+									position101, tokenIndex101 := position, tokenIndex
+									if buffer[position] != rune('T') {
+										goto l101
+									}
+									position++
+									{
+										position103 := position
+										if !_rules[rulepartialTime]() {
+											goto l101
+										}
+										{
+											position104 := position
+											{
+												position105, tokenIndex105 := position, tokenIndex
+												if buffer[position] != rune('Z') {
+													goto l106
+												}
+												position++
+												goto l105
+											l106:
+												position, tokenIndex = position105, tokenIndex105
+												{
+													position107 := position
+													{
+														position108, tokenIndex108 := position, tokenIndex
+														if buffer[position] != rune('-') {
+															goto l109
+														}
+														position++
+														goto l108
+													l109:
+														position, tokenIndex = position108, tokenIndex108
+														if buffer[position] != rune('+') {
+															goto l101
+														}
+														position++
+													}
+												l108:
+													if !_rules[ruletimeHour]() {
+														goto l101
+													}
+													if buffer[position] != rune(':') {
+														goto l101
+													}
+													position++
+													if !_rules[ruletimeMinute]() {
+														goto l101
+													}
+													add(ruletimeNumoffset, position107)
+												}
+											}
+										l105:
+											add(ruletimeOffset, position104)
+										}
+										add(rulefullTime, position103)
+									}
+									goto l102
+								l101:
+									position, tokenIndex = position101, tokenIndex101
+								}
+							l102:
+								goto l94
+							l95:
+								position, tokenIndex = position94, tokenIndex94
+								if !_rules[rulepartialTime]() {
+									goto l91
+								}
+							}
+						l94:
+							add(ruledatetime, position93)
+						}
+						add(rulePegText, position92)
+					}
+					{
+						add(ruleAction7, position)
+					}
+					goto l90
+				l91:
+					position, tokenIndex = position90, tokenIndex90
+					{
+						position112 := position
+						{
+							position113 := position
+							if !_rules[ruleinteger]() {
+								goto l111
+							}
+							{
+								position114, tokenIndex114 := position, tokenIndex
+								if !_rules[rulefrac]() {
+									goto l115
+								}
+								{
+									position116, tokenIndex116 := position, tokenIndex
+									if !_rules[ruleexp]() {
+										goto l116
+									}
+									goto l117
+								l116:
+									position, tokenIndex = position116, tokenIndex116
+								}
+							l117:
+								goto l114
+							l115:
+								position, tokenIndex = position114, tokenIndex114
+								{
+									position118, tokenIndex118 := position, tokenIndex
+									if !_rules[rulefrac]() {
+										goto l118
+									}
+									goto l119
+								l118:
+									position, tokenIndex = position118, tokenIndex118
+								}
+							l119:
+								if !_rules[ruleexp]() {
+									goto l111
+								}
+							}
+						l114:
+							add(rulefloat, position113)
+						}
+						add(rulePegText, position112)
+					}
+					{
+						add(ruleAction8, position)
+					}
+					goto l90
+				l111:
+					position, tokenIndex = position90, tokenIndex90
+					{
+						switch buffer[position] {
+						case '{':
+							{
+								position122 := position
+								if buffer[position] != rune('{') {
+									goto l88
+								}
+								position++
+								{
+									add(ruleAction15, position)
+								}
+								if !_rules[rulews]() {
+									goto l88
+								}
+								{
+									position124 := position
+								l125:
+									{
+										position126, tokenIndex126 := position, tokenIndex
+										if !_rules[rulekeyval]() {
+											goto l126
+										}
+										{
+											position127, tokenIndex127 := position, tokenIndex
+											{
+												position129 := position
+												if !_rules[rulews]() {
+													goto l127
+												}
+												if buffer[position] != rune(',') {
+													goto l127
+												}
+												position++
+												if !_rules[rulews]() {
+													goto l127
+												}
+												add(ruleinlineTableValSep, position129)
+											}
+											goto l128
+										l127:
+											position, tokenIndex = position127, tokenIndex127
+										}
+									l128:
+										goto l125
+									l126:
+										position, tokenIndex = position126, tokenIndex126
+									}
+									add(ruleinlineTableKeyValues, position124)
+								}
+								if !_rules[rulews]() {
+									goto l88
+								}
+								if buffer[position] != rune('}') {
+									goto l88
+								}
+								position++
+								{
+									add(ruleAction16, position)
+								}
+								add(ruleinlineTable, position122)
+							}
+							break
+						case '[':
+							{
+								position131 := position
+								{
+									position132 := position
+									if buffer[position] != rune('[') {
+										goto l88
+									}
+									position++
+									{
+										add(ruleAction22, position)
+									}
+									if !_rules[rulewsnl]() {
+										goto l88
+									}
+									{
+										position134, tokenIndex134 := position, tokenIndex
+										{
+											position136 := position
+											if !_rules[ruleval]() {
+												goto l134
+											}
+											{
+												add(ruleAction23, position)
+											}
+										l138:
+											{
+												position139, tokenIndex139 := position, tokenIndex
+												if !_rules[rulewsnl]() {
+													goto l139
+												}
+												{
+													position140, tokenIndex140 := position, tokenIndex
+													if !_rules[rulecomment]() {
+														goto l140
+													}
+													goto l141
+												l140:
+													position, tokenIndex = position140, tokenIndex140
+												}
+											l141:
+												if !_rules[rulewsnl]() {
+													goto l139
+												}
+												if !_rules[rulearraySep]() {
+													goto l139
+												}
+												if !_rules[rulewsnl]() {
+													goto l139
+												}
+												{
+													position142, tokenIndex142 := position, tokenIndex
+													if !_rules[rulecomment]() {
+														goto l142
+													}
+													goto l143
+												l142:
+													position, tokenIndex = position142, tokenIndex142
+												}
+											l143:
+												if !_rules[rulewsnl]() {
+													goto l139
+												}
+												if !_rules[ruleval]() {
+													goto l139
+												}
+												{
+													add(ruleAction24, position)
+												}
+												goto l138
+											l139:
+												position, tokenIndex = position139, tokenIndex139
+											}
+											if !_rules[rulewsnl]() {
+												goto l134
+											}
+											{
+												position145, tokenIndex145 := position, tokenIndex
+												if !_rules[rulearraySep]() {
+													goto l145
+												}
+												goto l146
+											l145:
+												position, tokenIndex = position145, tokenIndex145
+											}
+										l146:
+											if !_rules[rulewsnl]() {
+												goto l134
+											}
+											{
+												position147, tokenIndex147 := position, tokenIndex
+												if !_rules[rulecomment]() {
+													goto l147
+												}
+												goto l148
+											l147:
+												position, tokenIndex = position147, tokenIndex147
+											}
+										l148:
+											add(rulearrayValues, position136)
+										}
+										goto l135
+									l134:
+										position, tokenIndex = position134, tokenIndex134
+									}
+								l135:
+									if !_rules[rulewsnl]() {
+										goto l88
+									}
+									if buffer[position] != rune(']') {
+										goto l88
+									}
+									position++
+									add(rulearray, position132)
+								}
+								add(rulePegText, position131)
+							}
+							{
+								add(ruleAction12, position)
+							}
+							break
+						case 'f', 't':
+							{
+								position150 := position
+								{
+									position151 := position
+									{
+										position152, tokenIndex152 := position, tokenIndex
+										if buffer[position] != rune('t') {
+											goto l153
+										}
+										position++
+										if buffer[position] != rune('r') {
+											goto l153
+										}
+										position++
+										if buffer[position] != rune('u') {
+											goto l153
+										}
+										position++
+										if buffer[position] != rune('e') {
+											goto l153
+										}
+										position++
+										goto l152
+									l153:
+										position, tokenIndex = position152, tokenIndex152
+										if buffer[position] != rune('f') {
+											goto l88
+										}
+										position++
+										if buffer[position] != rune('a') {
+											goto l88
+										}
+										position++
+										if buffer[position] != rune('l') {
+											goto l88
+										}
+										position++
+										if buffer[position] != rune('s') {
+											goto l88
+										}
+										position++
+										if buffer[position] != rune('e') {
+											goto l88
+										}
+										position++
+									}
+								l152:
+									add(ruleboolean, position151)
+								}
+								add(rulePegText, position150)
+							}
+							{
+								add(ruleAction11, position)
+							}
+							break
+						case '"', '\'':
+							{
+								position155 := position
+								{
+									position156 := position
+									{
+										position157, tokenIndex157 := position, tokenIndex
+										{
+											position159 := position
+											if buffer[position] != rune('\'') {
+												goto l158
+											}
+											position++
+											if buffer[position] != rune('\'') {
+												goto l158
+											}
+											position++
+											if buffer[position] != rune('\'') {
+												goto l158
+											}
+											position++
+											{
+												position160 := position
+												{
+													position161 := position
+												l162:
+													{
+														position163, tokenIndex163 := position, tokenIndex
+														{
+															position164, tokenIndex164 := position, tokenIndex
+															if buffer[position] != rune('\'') {
+																goto l164
+															}
+															position++
+															if buffer[position] != rune('\'') {
+																goto l164
+															}
+															position++
+															if buffer[position] != rune('\'') {
+																goto l164
+															}
+															position++
+															goto l163
+														l164:
+															position, tokenIndex = position164, tokenIndex164
+														}
+														{
+															position165, tokenIndex165 := position, tokenIndex
+															{
+																position167 := position
+																{
+																	position168, tokenIndex168 := position, tokenIndex
+																	if buffer[position] != rune('\t') {
+																		goto l169
+																	}
+																	position++
+																	goto l168
+																l169:
+																	position, tokenIndex = position168, tokenIndex168
+																	if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
+																		goto l166
+																	}
+																	position++
+																}
+															l168:
+																add(rulemlLiteralChar, position167)
+															}
+															goto l165
+														l166:
+															position, tokenIndex = position165, tokenIndex165
+															if !_rules[rulenewline]() {
+																goto l163
+															}
+														}
+													l165:
+														goto l162
+													l163:
+														position, tokenIndex = position163, tokenIndex163
+													}
+													add(rulemlLiteralBody, position161)
+												}
+												add(rulePegText, position160)
+											}
+											if buffer[position] != rune('\'') {
+												goto l158
+											}
+											position++
+											if buffer[position] != rune('\'') {
+												goto l158
+											}
+											position++
+											if buffer[position] != rune('\'') {
+												goto l158
+											}
+											position++
+											{
+												add(ruleAction21, position)
+											}
+											add(rulemlLiteralString, position159)
+										}
+										goto l157
+									l158:
+										position, tokenIndex = position157, tokenIndex157
+										{
+											position172 := position
+											if buffer[position] != rune('\'') {
+												goto l171
+											}
+											position++
+											{
+												position173 := position
+											l174:
+												{
+													position175, tokenIndex175 := position, tokenIndex
+													{
+														position176 := position
+														{
+															switch buffer[position] {
+															case '\t':
+																if buffer[position] != rune('\t') {
+																	goto l175
+																}
+																position++
+																break
+															case ' ', '!', '"', '#', '$', '%', '&':
+																if c := buffer[position]; c < rune(' ') || c > rune('&') {
+																	goto l175
+																}
+																position++
+																break
+															default:
+																if c := buffer[position]; c < rune('(') || c > rune('\U0010ffff') {
+																	goto l175
+																}
+																position++
+																break
+															}
+														}
+
+														add(ruleliteralChar, position176)
+													}
+													goto l174
+												l175:
+													position, tokenIndex = position175, tokenIndex175
+												}
+												add(rulePegText, position173)
+											}
+											if buffer[position] != rune('\'') {
+												goto l171
+											}
+											position++
+											{
+												add(ruleAction20, position)
+											}
+											add(ruleliteralString, position172)
+										}
+										goto l157
+									l171:
+										position, tokenIndex = position157, tokenIndex157
+										{
+											position180 := position
+											if buffer[position] != rune('"') {
+												goto l179
+											}
+											position++
+											if buffer[position] != rune('"') {
+												goto l179
+											}
+											position++
+											if buffer[position] != rune('"') {
+												goto l179
+											}
+											position++
+											{
+												position181 := position
+											l182:
+												{
+													position183, tokenIndex183 := position, tokenIndex
+													{
+														position184, tokenIndex184 := position, tokenIndex
+														{
+															position186 := position
+															{
+																position187, tokenIndex187 := position, tokenIndex
+																if !_rules[rulebasicChar]() {
+																	goto l188
+																}
+																goto l187
+															l188:
+																position, tokenIndex = position187, tokenIndex187
+																if !_rules[rulenewline]() {
+																	goto l185
+																}
+															}
+														l187:
+															add(rulePegText, position186)
+														}
+														{
+															add(ruleAction19, position)
+														}
+														goto l184
+													l185:
+														position, tokenIndex = position184, tokenIndex184
+														if !_rules[ruleescape]() {
+															goto l183
+														}
+														if !_rules[rulenewline]() {
+															goto l183
+														}
+														if !_rules[rulewsnl]() {
+															goto l183
+														}
+													}
+												l184:
+													goto l182
+												l183:
+													position, tokenIndex = position183, tokenIndex183
+												}
+												add(rulemlBasicBody, position181)
+											}
+											if buffer[position] != rune('"') {
+												goto l179
+											}
+											position++
+											if buffer[position] != rune('"') {
+												goto l179
+											}
+											position++
+											if buffer[position] != rune('"') {
+												goto l179
+											}
+											position++
+											{
+												add(ruleAction18, position)
+											}
+											add(rulemlBasicString, position180)
+										}
+										goto l157
+									l179:
+										position, tokenIndex = position157, tokenIndex157
+										{
+											position191 := position
+											{
+												position192 := position
+												if buffer[position] != rune('"') {
+													goto l88
+												}
+												position++
+											l193:
+												{
+													position194, tokenIndex194 := position, tokenIndex
+													if !_rules[rulebasicChar]() {
+														goto l194
+													}
+													goto l193
+												l194:
+													position, tokenIndex = position194, tokenIndex194
+												}
+												if buffer[position] != rune('"') {
+													goto l88
+												}
+												position++
+												add(rulePegText, position192)
+											}
+											{
+												add(ruleAction17, position)
+											}
+											add(rulebasicString, position191)
+										}
+									}
+								l157:
+									add(rulestring, position156)
+								}
+								add(rulePegText, position155)
+							}
+							{
+								add(ruleAction10, position)
+							}
+							break
+						default:
+							{
+								position197 := position
+								if !_rules[ruleinteger]() {
+									goto l88
+								}
+								add(rulePegText, position197)
+							}
+							{
+								add(ruleAction9, position)
+							}
+							break
+						}
+					}
+
+				}
+			l90:
+				add(ruleval, position89)
+			}
+			return true
+		l88:
+			position, tokenIndex = position88, tokenIndex88
+			return false
+		},
+		/* 11 table <- <(stdTable / arrayTable)> */
+		nil,
+		/* 12 stdTable <- <('[' ws <tableKey> ws ']' Action13)> */
+		nil,
+		/* 13 arrayTable <- <('[' '[' ws <tableKey> ws (']' ']') Action14)> */
+		nil,
+		/* 14 inlineTable <- <('{' Action15 ws inlineTableKeyValues ws '}' Action16)> */
+		nil,
+		/* 15 inlineTableKeyValues <- <(keyval inlineTableValSep?)*> */
+		nil,
+		/* 16 tableKey <- <(key (tableKeySep key)*)> */
+		func() bool {
+			position204, tokenIndex204 := position, tokenIndex
+			{
+				position205 := position
+				if !_rules[rulekey]() {
+					goto l204
+				}
+			l206:
+				{
+					position207, tokenIndex207 := position, tokenIndex
+					{
+						position208 := position
+						if !_rules[rulews]() {
+							goto l207
+						}
+						if buffer[position] != rune('.') {
+							goto l207
+						}
+						position++
+						if !_rules[rulews]() {
+							goto l207
+						}
+						add(ruletableKeySep, position208)
+					}
+					if !_rules[rulekey]() {
+						goto l207
+					}
+					goto l206
+				l207:
+					position, tokenIndex = position207, tokenIndex207
+				}
+				add(ruletableKey, position205)
+			}
+			return true
+		l204:
+			position, tokenIndex = position204, tokenIndex204
+			return false
+		},
+		/* 17 tableKeySep <- <(ws '.' ws)> */
+		nil,
+		/* 18 inlineTableValSep <- <(ws ',' ws)> */
+		nil,
+		/* 19 integer <- <(('-' / '+')? int)> */
+		func() bool {
+			position211, tokenIndex211 := position, tokenIndex
+			{
+				position212 := position
+				{
+					position213, tokenIndex213 := position, tokenIndex
+					{
+						position215, tokenIndex215 := position, tokenIndex
+						if buffer[position] != rune('-') {
+							goto l216
+						}
+						position++
+						goto l215
+					l216:
+						position, tokenIndex = position215, tokenIndex215
+						if buffer[position] != rune('+') {
+							goto l213
+						}
+						position++
+					}
+				l215:
+					goto l214
+				l213:
+					position, tokenIndex = position213, tokenIndex213
+				}
+			l214:
+				{
+					position217 := position
+					{
+						position218, tokenIndex218 := position, tokenIndex
+						if c := buffer[position]; c < rune('1') || c > rune('9') {
+							goto l219
+						}
+						position++
+						{
+							position222, tokenIndex222 := position, tokenIndex
+							if !_rules[ruledigit]() {
+								goto l223
+							}
+							goto l222
+						l223:
+							position, tokenIndex = position222, tokenIndex222
+							if buffer[position] != rune('_') {
+								goto l219
+							}
+							position++
+							if !_rules[ruledigit]() {
+								goto l219
+							}
+						}
+					l222:
+					l220:
+						{
+							position221, tokenIndex221 := position, tokenIndex
+							{
+								position224, tokenIndex224 := position, tokenIndex
+								if !_rules[ruledigit]() {
+									goto l225
+								}
+								goto l224
+							l225:
+								position, tokenIndex = position224, tokenIndex224
+								if buffer[position] != rune('_') {
+									goto l221
+								}
+								position++
+								if !_rules[ruledigit]() {
+									goto l221
+								}
+							}
+						l224:
+							goto l220
+						l221:
+							position, tokenIndex = position221, tokenIndex221
+						}
+						goto l218
+					l219:
+						position, tokenIndex = position218, tokenIndex218
+						if !_rules[ruledigit]() {
+							goto l211
+						}
+					}
+				l218:
+					add(ruleint, position217)
+				}
+				add(ruleinteger, position212)
+			}
+			return true
+		l211:
+			position, tokenIndex = position211, tokenIndex211
+			return false
+		},
+		/* 20 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
+		nil,
+		/* 21 float <- <(integer ((frac exp?) / (frac? exp)))> */
+		nil,
+		/* 22 frac <- <('.' digit (digit / ('_' digit))*)> */
+		func() bool {
+			position228, tokenIndex228 := position, tokenIndex
+			{
+				position229 := position
+				if buffer[position] != rune('.') {
+					goto l228
+				}
+				position++
+				if !_rules[ruledigit]() {
+					goto l228
+				}
+			l230:
+				{
+					position231, tokenIndex231 := position, tokenIndex
+					{
+						position232, tokenIndex232 := position, tokenIndex
+						if !_rules[ruledigit]() {
+							goto l233
+						}
+						goto l232
+					l233:
+						position, tokenIndex = position232, tokenIndex232
+						if buffer[position] != rune('_') {
+							goto l231
+						}
+						position++
+						if !_rules[ruledigit]() {
+							goto l231
+						}
+					}
+				l232:
+					goto l230
+				l231:
+					position, tokenIndex = position231, tokenIndex231
+				}
+				add(rulefrac, position229)
+			}
+			return true
+		l228:
+			position, tokenIndex = position228, tokenIndex228
+			return false
+		},
+		/* 23 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
+		func() bool {
+			position234, tokenIndex234 := position, tokenIndex
+			{
+				position235 := position
+				{
+					position236, tokenIndex236 := position, tokenIndex
+					if buffer[position] != rune('e') {
+						goto l237
+					}
+					position++
+					goto l236
+				l237:
+					position, tokenIndex = position236, tokenIndex236
+					if buffer[position] != rune('E') {
+						goto l234
+					}
+					position++
+				}
+			l236:
+				{
+					position238, tokenIndex238 := position, tokenIndex
+					{
+						position240, tokenIndex240 := position, tokenIndex
+						if buffer[position] != rune('-') {
+							goto l241
+						}
+						position++
+						goto l240
+					l241:
+						position, tokenIndex = position240, tokenIndex240
+						if buffer[position] != rune('+') {
+							goto l238
+						}
+						position++
+					}
+				l240:
+					goto l239
+				l238:
+					position, tokenIndex = position238, tokenIndex238
+				}
+			l239:
+				if !_rules[ruledigit]() {
+					goto l234
+				}
+			l242:
+				{
+					position243, tokenIndex243 := position, tokenIndex
+					{
+						position244, tokenIndex244 := position, tokenIndex
+						if !_rules[ruledigit]() {
+							goto l245
+						}
+						goto l244
+					l245:
+						position, tokenIndex = position244, tokenIndex244
+						if buffer[position] != rune('_') {
+							goto l243
+						}
+						position++
+						if !_rules[ruledigit]() {
+							goto l243
+						}
+					}
+				l244:
+					goto l242
+				l243:
+					position, tokenIndex = position243, tokenIndex243
+				}
+				add(ruleexp, position235)
+			}
+			return true
+		l234:
+			position, tokenIndex = position234, tokenIndex234
+			return false
+		},
+		/* 24 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
+		nil,
+		/* 25 basicString <- <(<('"' basicChar* '"')> Action17)> */
+		nil,
+		/* 26 basicChar <- <(basicUnescaped / escaped)> */
+		func() bool {
+			position248, tokenIndex248 := position, tokenIndex
+			{
+				position249 := position
+				{
+					position250, tokenIndex250 := position, tokenIndex
+					{
+						position252 := position
+						{
+							switch buffer[position] {
+							case ' ', '!':
+								if c := buffer[position]; c < rune(' ') || c > rune('!') {
+									goto l251
+								}
+								position++
+								break
+							case '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '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', '[':
+								if c := buffer[position]; c < rune('#') || c > rune('[') {
+									goto l251
+								}
+								position++
+								break
+							default:
+								if c := buffer[position]; c < rune(']') || c > rune('\U0010ffff') {
+									goto l251
+								}
+								position++
+								break
+							}
+						}
+
+						add(rulebasicUnescaped, position252)
+					}
+					goto l250
+				l251:
+					position, tokenIndex = position250, tokenIndex250
+					{
+						position254 := position
+						if !_rules[ruleescape]() {
+							goto l248
+						}
+						{
+							switch buffer[position] {
+							case 'U':
+								if buffer[position] != rune('U') {
+									goto l248
+								}
+								position++
+								if !_rules[rulehexQuad]() {
+									goto l248
+								}
+								if !_rules[rulehexQuad]() {
+									goto l248
+								}
+								break
+							case 'u':
+								if buffer[position] != rune('u') {
+									goto l248
+								}
+								position++
+								if !_rules[rulehexQuad]() {
+									goto l248
+								}
+								break
+							case '\\':
+								if buffer[position] != rune('\\') {
+									goto l248
+								}
+								position++
+								break
+							case '/':
+								if buffer[position] != rune('/') {
+									goto l248
+								}
+								position++
+								break
+							case '"':
+								if buffer[position] != rune('"') {
+									goto l248
+								}
+								position++
+								break
+							case 'r':
+								if buffer[position] != rune('r') {
+									goto l248
+								}
+								position++
+								break
+							case 'f':
+								if buffer[position] != rune('f') {
+									goto l248
+								}
+								position++
+								break
+							case 'n':
+								if buffer[position] != rune('n') {
+									goto l248
+								}
+								position++
+								break
+							case 't':
+								if buffer[position] != rune('t') {
+									goto l248
+								}
+								position++
+								break
+							default:
+								if buffer[position] != rune('b') {
+									goto l248
+								}
+								position++
+								break
+							}
+						}
+
+						add(ruleescaped, position254)
+					}
+				}
+			l250:
+				add(rulebasicChar, position249)
+			}
+			return true
+		l248:
+			position, tokenIndex = position248, tokenIndex248
+			return false
+		},
+		/* 27 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
+		nil,
+		/* 28 basicUnescaped <- <((&(' ' | '!') [ -!]) | (&('#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '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' | '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' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') []-\U0010ffff]))> */
+		nil,
+		/* 29 escape <- <'\\'> */
+		func() bool {
+			position258, tokenIndex258 := position, tokenIndex
+			{
+				position259 := position
+				if buffer[position] != rune('\\') {
+					goto l258
+				}
+				position++
+				add(ruleescape, position259)
+			}
+			return true
+		l258:
+			position, tokenIndex = position258, tokenIndex258
+			return false
+		},
+		/* 30 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action18)> */
+		nil,
+		/* 31 mlBasicBody <- <((<(basicChar / newline)> Action19) / (escape newline wsnl))*> */
+		nil,
+		/* 32 literalString <- <('\'' <literalChar*> '\'' Action20)> */
+		nil,
+		/* 33 literalChar <- <((&('\t') '\t') | (&(' ' | '!' | '"' | '#' | '$' | '%' | '&') [ -&]) | (&('(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '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' | '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' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') [(-\U0010ffff]))> */
+		nil,
+		/* 34 mlLiteralString <- <('\'' '\'' '\'' <mlLiteralBody> ('\'' '\'' '\'') Action21)> */
+		nil,
+		/* 35 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
+		nil,
+		/* 36 mlLiteralChar <- <('\t' / [ -\U0010ffff])> */
+		nil,
+		/* 37 hexdigit <- <((&('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]))> */
+		func() bool {
+			position267, tokenIndex267 := position, tokenIndex
+			{
+				position268 := position
+				{
+					switch buffer[position] {
+					case 'a', 'b', 'c', 'd', 'e', 'f':
+						if c := buffer[position]; c < rune('a') || c > rune('f') {
+							goto l267
+						}
+						position++
+						break
+					case 'A', 'B', 'C', 'D', 'E', 'F':
+						if c := buffer[position]; c < rune('A') || c > rune('F') {
+							goto l267
+						}
+						position++
+						break
+					default:
+						if c := buffer[position]; c < rune('0') || c > rune('9') {
+							goto l267
+						}
+						position++
+						break
+					}
+				}
+
+				add(rulehexdigit, position268)
+			}
+			return true
+		l267:
+			position, tokenIndex = position267, tokenIndex267
+			return false
+		},
+		/* 38 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
+		func() bool {
+			position270, tokenIndex270 := position, tokenIndex
+			{
+				position271 := position
+				if !_rules[rulehexdigit]() {
+					goto l270
+				}
+				if !_rules[rulehexdigit]() {
+					goto l270
+				}
+				if !_rules[rulehexdigit]() {
+					goto l270
+				}
+				if !_rules[rulehexdigit]() {
+					goto l270
+				}
+				add(rulehexQuad, position271)
+			}
+			return true
+		l270:
+			position, tokenIndex = position270, tokenIndex270
+			return false
+		},
+		/* 39 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
+		nil,
+		/* 40 dateFullYear <- <digitQuad> */
+		nil,
+		/* 41 dateMonth <- <digitDual> */
+		nil,
+		/* 42 dateMDay <- <digitDual> */
+		nil,
+		/* 43 timeHour <- <digitDual> */
+		func() bool {
+			position276, tokenIndex276 := position, tokenIndex
+			{
+				position277 := position
+				if !_rules[ruledigitDual]() {
+					goto l276
+				}
+				add(ruletimeHour, position277)
+			}
+			return true
+		l276:
+			position, tokenIndex = position276, tokenIndex276
+			return false
+		},
+		/* 44 timeMinute <- <digitDual> */
+		func() bool {
+			position278, tokenIndex278 := position, tokenIndex
+			{
+				position279 := position
+				if !_rules[ruledigitDual]() {
+					goto l278
+				}
+				add(ruletimeMinute, position279)
+			}
+			return true
+		l278:
+			position, tokenIndex = position278, tokenIndex278
+			return false
+		},
+		/* 45 timeSecond <- <digitDual> */
+		nil,
+		/* 46 timeSecfrac <- <('.' digit+)> */
+		nil,
+		/* 47 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
+		nil,
+		/* 48 timeOffset <- <('Z' / timeNumoffset)> */
+		nil,
+		/* 49 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
+		func() bool {
+			position284, tokenIndex284 := position, tokenIndex
+			{
+				position285 := position
+				if !_rules[ruletimeHour]() {
+					goto l284
+				}
+				if buffer[position] != rune(':') {
+					goto l284
+				}
+				position++
+				if !_rules[ruletimeMinute]() {
+					goto l284
+				}
+				if buffer[position] != rune(':') {
+					goto l284
+				}
+				position++
+				{
+					position286 := position
+					if !_rules[ruledigitDual]() {
+						goto l284
+					}
+					add(ruletimeSecond, position286)
+				}
+				{
+					position287, tokenIndex287 := position, tokenIndex
+					{
+						position289 := position
+						if buffer[position] != rune('.') {
+							goto l287
+						}
+						position++
+						if !_rules[ruledigit]() {
+							goto l287
+						}
+					l290:
+						{
+							position291, tokenIndex291 := position, tokenIndex
+							if !_rules[ruledigit]() {
+								goto l291
+							}
+							goto l290
+						l291:
+							position, tokenIndex = position291, tokenIndex291
+						}
+						add(ruletimeSecfrac, position289)
+					}
+					goto l288
+				l287:
+					position, tokenIndex = position287, tokenIndex287
+				}
+			l288:
+				add(rulepartialTime, position285)
+			}
+			return true
+		l284:
+			position, tokenIndex = position284, tokenIndex284
+			return false
+		},
+		/* 50 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
+		nil,
+		/* 51 fullTime <- <(partialTime timeOffset)> */
+		nil,
+		/* 52 datetime <- <((fullDate ('T' fullTime)?) / partialTime)> */
+		nil,
+		/* 53 digit <- <[0-9]> */
+		func() bool {
+			position295, tokenIndex295 := position, tokenIndex
+			{
+				position296 := position
+				if c := buffer[position]; c < rune('0') || c > rune('9') {
+					goto l295
+				}
+				position++
+				add(ruledigit, position296)
+			}
+			return true
+		l295:
+			position, tokenIndex = position295, tokenIndex295
+			return false
+		},
+		/* 54 digitDual <- <(digit digit)> */
+		func() bool {
+			position297, tokenIndex297 := position, tokenIndex
+			{
+				position298 := position
+				if !_rules[ruledigit]() {
+					goto l297
+				}
+				if !_rules[ruledigit]() {
+					goto l297
+				}
+				add(ruledigitDual, position298)
+			}
+			return true
+		l297:
+			position, tokenIndex = position297, tokenIndex297
+			return false
+		},
+		/* 55 digitQuad <- <(digitDual digitDual)> */
+		nil,
+		/* 56 array <- <('[' Action22 wsnl arrayValues? wsnl ']')> */
+		nil,
+		/* 57 arrayValues <- <(val Action23 (wsnl comment? wsnl arraySep wsnl comment? wsnl val Action24)* wsnl arraySep? wsnl comment?)> */
+		nil,
+		/* 58 arraySep <- <','> */
+		func() bool {
+			position302, tokenIndex302 := position, tokenIndex
+			{
+				position303 := position
+				if buffer[position] != rune(',') {
+					goto l302
+				}
+				position++
+				add(rulearraySep, position303)
+			}
+			return true
+		l302:
+			position, tokenIndex = position302, tokenIndex302
+			return false
+		},
+		/* 60 Action0 <- <{ _ = buffer }> */
+		nil,
+		nil,
+		/* 62 Action1 <- <{ p.SetTableString(begin, end) }> */
+		nil,
+		/* 63 Action2 <- <{ p.AddLineCount(end - begin) }> */
+		nil,
+		/* 64 Action3 <- <{ p.AddLineCount(end - begin) }> */
+		nil,
+		/* 65 Action4 <- <{ p.AddKeyValue() }> */
+		nil,
+		/* 66 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
+		nil,
+		/* 67 Action6 <- <{ p.SetKey(p.buffer, begin-1, end+1) }> */
+		nil,
+		/* 68 Action7 <- <{ p.SetTime(begin, end) }> */
+		nil,
+		/* 69 Action8 <- <{ p.SetFloat64(begin, end) }> */
+		nil,
+		/* 70 Action9 <- <{ p.SetInt64(begin, end) }> */
+		nil,
+		/* 71 Action10 <- <{ p.SetString(begin, end) }> */
+		nil,
+		/* 72 Action11 <- <{ p.SetBool(begin, end) }> */
+		nil,
+		/* 73 Action12 <- <{ p.SetArray(begin, end) }> */
+		nil,
+		/* 74 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
+		nil,
+		/* 75 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
+		nil,
+		/* 76 Action15 <- <{ p.StartInlineTable() }> */
+		nil,
+		/* 77 Action16 <- <{ p.EndInlineTable() }> */
+		nil,
+		/* 78 Action17 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
+		nil,
+		/* 79 Action18 <- <{ p.SetMultilineString() }> */
+		nil,
+		/* 80 Action19 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
+		nil,
+		/* 81 Action20 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
+		nil,
+		/* 82 Action21 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
+		nil,
+		/* 83 Action22 <- <{ p.StartArray() }> */
+		nil,
+		/* 84 Action23 <- <{ p.AddArrayVal() }> */
+		nil,
+		/* 85 Action24 <- <{ p.AddArrayVal() }> */
+		nil,
+	}
+	p.rules = _rules
+}