github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/ast/spl/spl.go

// Code generated by pigeon; DO NOT EDIT.

package spl

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math"
	"os"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"unicode"
	"unicode/utf8"

	"github.com/siglens/siglens/pkg/ast"
	"github.com/siglens/siglens/pkg/segment/aggregations"
	"github.com/siglens/siglens/pkg/segment/query"
	"github.com/siglens/siglens/pkg/segment/structs"
	"github.com/siglens/siglens/pkg/segment/utils"
	log "github.com/sirupsen/logrus"
)

func getParseError(err error) error {
	switch ev := err.(type) {
	case errList:
		if pe, ok := ev[0].(*parserError); ok {
			return &ast.ParseError{
				Inner:    pe.Inner,
				Line:     pe.pos.line,
				Column:   pe.pos.col,
				Offset:   pe.pos.offset,
				Prefix:   pe.prefix,
				Expected: pe.expected,
			}
		}
	}
	return err
}

// Remove the first and last character of the string
func removeQuotes(s any) string {
	str := s.(string)
	if len(str) < 3 {
		return ""
	}

	return str[1 : len(str)-1]
}

// Check if it rename fields with similar names using a wildcard
func isRegexRename(originalPattern, newPattern string) (bool, error) {
	oldWildcards := strings.Count(originalPattern, "*")
	newWildcards := strings.Count(newPattern, "*")

	if oldWildcards == 0 && newWildcards == 0 {
		return false, nil
	} else if oldWildcards > 0 && oldWildcards == newWildcards {
		return true, nil
	} else {
		return false, errors.New("Patterns do not match")
	}
}

func deMorgansLaw(node *ast.Node) {
	switch node.NodeType {
	case ast.NodeTerminal:
		switch node.Comparison.Op {
		case "=":
			node.Comparison.Op = "!="
		case "!=":
			node.Comparison.Op = "="
		case ">":
			node.Comparison.Op = "<="
		case "<":
			node.Comparison.Op = ">="
		case ">=":
			node.Comparison.Op = "<"
		case "<=":
			node.Comparison.Op = ">"
		default:
			log.Errorf("deMorgansLaw: unexpected node comparison op: %v", node.Comparison.Op)
		}
	case ast.NodeAnd:
		node.NodeType = ast.NodeOr
		deMorgansLaw(node.Left)
		deMorgansLaw(node.Right)
	case ast.NodeOr:
		node.NodeType = ast.NodeAnd
		deMorgansLaw(node.Left)
		deMorgansLaw(node.Right)
	default:
		log.Errorf("deMorgansLaw: unexpected NodeType: %v", node.NodeType)
	}
}

// Generate NumericExpr struct for eval functions
func createNumericExpr(op string, leftNumericExpr *structs.NumericExpr, rightNumericExpr *structs.NumericExpr, numericExprMode structs.NumericExprMode) (*structs.NumericExpr, error) {
	if leftNumericExpr == nil {
		return nil, fmt.Errorf("expr cannot be nil")
	}

	return &structs.NumericExpr{
		IsTerminal:      false,
		Op:              op,
		Left:            leftNumericExpr,
		Right:           rightNumericExpr,
		NumericExprMode: numericExprMode,
	}, nil
}

func transferUint8ToString(opName interface{}) (string, error) {
	strData, ok := opName.([]byte)
	if !ok {
		return "", fmt.Errorf("opName is not a []byte")
	}

	opNameStr := string(strData)
	return opNameStr, nil
}

func transferPCREToRE2(pattern string) string {
	pattern = strings.Replace(pattern, "(?<", "(?P<", -1)
	return pattern
}

func getRexColNames(pattern string) ([]string, error) {
	re, err := regexp.Compile(`\?<(?P<GroupName>[a-zA-Z0-9_]+)>`)
	if err != nil {
		return nil, fmt.Errorf("getRexColNames: There are some errors in the pattern: %v", err)
	}
	matches := re.FindAllStringSubmatch(pattern, -1)

	var rexColNames []string
	for _, match := range matches {
		rexColNames = append(rexColNames, match[1])
	}

	return rexColNames, nil
}

type aggregator struct {
	measureAgg         *structs.MeasureAggregator
	renameOutputField  bool
	outputFieldNewName string
}

type singleAggTemp struct {
	aggregators   []*aggregator
	SplitByClause *structs.SplitByClause
}

type TxnArgs struct {
	argOption string
	arguments *structs.TransactionArguments
}

type TimechartArgs struct {
	singleAggExpr *singleAggTemp
	// Todo: Add eval clause expr.
	tcOptions *structs.TcOptions
}

var g = &grammar{
	rules: []*rule{
		{
			name: "Start",
			pos:  position{line: 157, col: 1, offset: 4199},
			expr: &actionExpr{
				pos: position{line: 157, col: 10, offset: 4208},
				run: (*parser).callonStart1,
				expr: &seqExpr{
					pos: position{line: 157, col: 10, offset: 4208},
					exprs: []any{
						&zeroOrOneExpr{
							pos: position{line: 157, col: 10, offset: 4208},
							expr: &ruleRefExpr{
								pos:  position{line: 157, col: 10, offset: 4208},
								name: "SPACE",
							},
						},
						&labeledExpr{
							pos:   position{line: 157, col: 17, offset: 4215},
							label: "initialSearch",
							expr: &ruleRefExpr{
								pos:  position{line: 157, col: 32, offset: 4230},
								name: "InitialSearchBlock",
							},
						},
						&labeledExpr{
							pos:   position{line: 157, col: 52, offset: 4250},
							label: "filterBlocks",
							expr: &zeroOrMoreExpr{
								pos: position{line: 157, col: 65, offset: 4263},
								expr: &ruleRefExpr{
									pos:  position{line: 157, col: 66, offset: 4264},
									name: "FilterBlock",
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 157, col: 80, offset: 4278},
							label: "queryAggBlocks",
							expr: &zeroOrMoreExpr{
								pos: position{line: 157, col: 95, offset: 4293},
								expr: &ruleRefExpr{
									pos:  position{line: 157, col: 96, offset: 4294},
									name: "QueryAggergatorBlock",
								},
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 157, col: 119, offset: 4317},
							expr: &ruleRefExpr{
								pos:  position{line: 157, col: 119, offset: 4317},
								name: "SPACE",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 157, col: 126, offset: 4324},
							name: "EOF",
						},
					},
				},
			},
		},
		{
			name: "InitialSearchBlock",
			pos:  position{line: 228, col: 1, offset: 6525},
			expr: &actionExpr{
				pos: position{line: 228, col: 23, offset: 6547},
				run: (*parser).callonInitialSearchBlock1,
				expr: &seqExpr{
					pos: position{line: 228, col: 23, offset: 6547},
					exprs: []any{
						&zeroOrOneExpr{
							pos: position{line: 228, col: 23, offset: 6547},
							expr: &ruleRefExpr{
								pos:  position{line: 228, col: 23, offset: 6547},
								name: "CMD_SEARCH",
							},
						},
						&labeledExpr{
							pos:   position{line: 228, col: 35, offset: 6559},
							label: "clause",
							expr: &ruleRefExpr{
								pos:  position{line: 228, col: 42, offset: 6566},
								name: "ClauseLevel4",
							},
						},
					},
				},
			},
		},
		{
			name: "SearchBlock",
			pos:  position{line: 232, col: 1, offset: 6607},
			expr: &actionExpr{
				pos: position{line: 232, col: 16, offset: 6622},
				run: (*parser).callonSearchBlock1,
				expr: &seqExpr{
					pos: position{line: 232, col: 16, offset: 6622},
					exprs: []any{
						&notExpr{
							pos: position{line: 232, col: 16, offset: 6622},
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 18, offset: 6624},
								name: "ALLCMD",
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 232, col: 26, offset: 6632},
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 26, offset: 6632},
								name: "CMD_SEARCH",
							},
						},
						&labeledExpr{
							pos:   position{line: 232, col: 38, offset: 6644},
							label: "clause",
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 45, offset: 6651},
								name: "ClauseLevel4",
							},
						},
					},
				},
			},
		},
		{
			name: "FilterBlock",
			pos:  position{line: 236, col: 1, offset: 6692},
			expr: &actionExpr{
				pos: position{line: 236, col: 16, offset: 6707},
				run: (*parser).callonFilterBlock1,
				expr: &seqExpr{
					pos: position{line: 236, col: 16, offset: 6707},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 236, col: 16, offset: 6707},
							name: "PIPE",
						},
						&labeledExpr{
							pos:   position{line: 236, col: 21, offset: 6712},
							label: "block",
							expr: &choiceExpr{
								pos: position{line: 236, col: 28, offset: 6719},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 236, col: 28, offset: 6719},
										name: "SearchBlock",
									},
									&ruleRefExpr{
										pos:  position{line: 236, col: 42, offset: 6733},
										name: "RegexBlock",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "QueryAggergatorBlock",
			pos:  position{line: 241, col: 1, offset: 6809},
			expr: &actionExpr{
				pos: position{line: 241, col: 25, offset: 6833},
				run: (*parser).callonQueryAggergatorBlock1,
				expr: &labeledExpr{
					pos:   position{line: 241, col: 25, offset: 6833},
					label: "block",
					expr: &choiceExpr{
						pos: position{line: 241, col: 32, offset: 6840},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 241, col: 32, offset: 6840},
								name: "FieldSelectBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 51, offset: 6859},
								name: "AggregatorBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 69, offset: 6877},
								name: "EvalBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 81, offset: 6889},
								name: "WhereBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 94, offset: 6902},
								name: "HeadBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 106, offset: 6914},
								name: "RexBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 117, offset: 6925},
								name: "StatisticBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 134, offset: 6942},
								name: "RenameBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 148, offset: 6956},
								name: "TimechartBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 165, offset: 6973},
								name: "TransactionBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 184, offset: 6992},
								name: "DedupBlock",
							},
							&ruleRefExpr{
								pos:  position{line: 241, col: 197, offset: 7005},
								name: "SortBlock",
							},
						},
					},
				},
			},
		},
		{
			name: "FieldSelectBlock",
			pos:  position{line: 246, col: 1, offset: 7096},
			expr: &actionExpr{
				pos: position{line: 246, col: 21, offset: 7116},
				run: (*parser).callonFieldSelectBlock1,
				expr: &seqExpr{
					pos: position{line: 246, col: 21, offset: 7116},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 246, col: 21, offset: 7116},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 246, col: 26, offset: 7121},
							name: "CMD_FIELDS",
						},
						&labeledExpr{
							pos:   position{line: 246, col: 37, offset: 7132},
							label: "op",
							expr: &zeroOrOneExpr{
								pos: position{line: 246, col: 40, offset: 7135},
								expr: &choiceExpr{
									pos: position{line: 246, col: 41, offset: 7136},
									alternatives: []any{
										&litMatcher{
											pos:        position{line: 246, col: 41, offset: 7136},
											val:        "-",
											ignoreCase: false,
											want:       "\"-\"",
										},
										&litMatcher{
											pos:        position{line: 246, col: 47, offset: 7142},
											val:        "+",
											ignoreCase: false,
											want:       "\"+\"",
										},
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 246, col: 53, offset: 7148},
							name: "EMPTY_OR_SPACE",
						},
						&labeledExpr{
							pos:   position{line: 246, col: 68, offset: 7163},
							label: "fields",
							expr: &ruleRefExpr{
								pos:  position{line: 246, col: 75, offset: 7170},
								name: "FieldNameList",
							},
						},
					},
				},
			},
		},
		{
			name: "AggregatorBlock",
			pos:  position{line: 264, col: 1, offset: 7674},
			expr: &actionExpr{
				pos: position{line: 264, col: 20, offset: 7693},
				run: (*parser).callonAggregatorBlock1,
				expr: &seqExpr{
					pos: position{line: 264, col: 20, offset: 7693},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 264, col: 20, offset: 7693},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 264, col: 25, offset: 7698},
							name: "CMD_STATS",
						},
						&labeledExpr{
							pos:   position{line: 264, col: 35, offset: 7708},
							label: "aggs",
							expr: &ruleRefExpr{
								pos:  position{line: 264, col: 40, offset: 7713},
								name: "AggregationList",
							},
						},
						&labeledExpr{
							pos:   position{line: 264, col: 56, offset: 7729},
							label: "byFields",
							expr: &zeroOrOneExpr{
								pos: position{line: 264, col: 65, offset: 7738},
								expr: &ruleRefExpr{
									pos:  position{line: 264, col: 66, offset: 7739},
									name: "GroupbyBlock",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "GroupbyBlock",
			pos:  position{line: 309, col: 1, offset: 9233},
			expr: &actionExpr{
				pos: position{line: 309, col: 17, offset: 9249},
				run: (*parser).callonGroupbyBlock1,
				expr: &seqExpr{
					pos: position{line: 309, col: 17, offset: 9249},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 309, col: 17, offset: 9249},
							name: "BY",
						},
						&labeledExpr{
							pos:   position{line: 309, col: 20, offset: 9252},
							label: "fields",
							expr: &ruleRefExpr{
								pos:  position{line: 309, col: 27, offset: 9259},
								name: "FieldNameList",
							},
						},
					},
				},
			},
		},
		{
			name: "RegexBlock",
			pos:  position{line: 320, col: 1, offset: 9608},
			expr: &actionExpr{
				pos: position{line: 320, col: 15, offset: 9622},
				run: (*parser).callonRegexBlock1,
				expr: &seqExpr{
					pos: position{line: 320, col: 15, offset: 9622},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 320, col: 15, offset: 9622},
							name: "CMD_REGEX",
						},
						&labeledExpr{
							pos:   position{line: 320, col: 25, offset: 9632},
							label: "keyAndOp",
							expr: &zeroOrOneExpr{
								pos: position{line: 320, col: 34, offset: 9641},
								expr: &seqExpr{
									pos: position{line: 320, col: 35, offset: 9642},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 320, col: 35, offset: 9642},
											name: "FieldName",
										},
										&ruleRefExpr{
											pos:  position{line: 320, col: 45, offset: 9652},
											name: "EqualityOperator",
										},
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 320, col: 64, offset: 9671},
							label: "str",
							expr: &ruleRefExpr{
								pos:  position{line: 320, col: 68, offset: 9675},
								name: "QuotedString",
							},
						},
					},
				},
			},
		},
		{
			name: "ClauseLevel4",
			pos:  position{line: 348, col: 1, offset: 10254},
			expr: &actionExpr{
				pos: position{line: 348, col: 17, offset: 10270},
				run: (*parser).callonClauseLevel41,
				expr: &seqExpr{
					pos: position{line: 348, col: 17, offset: 10270},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 348, col: 17, offset: 10270},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 348, col: 23, offset: 10276},
								name: "ClauseLevel3",
							},
						},
						&labeledExpr{
							pos:   position{line: 348, col: 36, offset: 10289},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 348, col: 41, offset: 10294},
								expr: &seqExpr{
									pos: position{line: 348, col: 42, offset: 10295},
									exprs: []any{
										&choiceExpr{
											pos: position{line: 348, col: 43, offset: 10296},
											alternatives: []any{
												&ruleRefExpr{
													pos:  position{line: 348, col: 43, offset: 10296},
													name: "AND",
												},
												&ruleRefExpr{
													pos:  position{line: 348, col: 49, offset: 10302},
													name: "SPACE",
												},
											},
										},
										&ruleRefExpr{
											pos:  position{line: 348, col: 56, offset: 10309},
											name: "ClauseLevel3",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ClauseLevel3",
			pos:  position{line: 366, col: 1, offset: 10686},
			expr: &actionExpr{
				pos: position{line: 366, col: 17, offset: 10702},
				run: (*parser).callonClauseLevel31,
				expr: &seqExpr{
					pos: position{line: 366, col: 17, offset: 10702},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 366, col: 17, offset: 10702},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 366, col: 23, offset: 10708},
								name: "ClauseLevel2",
							},
						},
						&labeledExpr{
							pos:   position{line: 366, col: 36, offset: 10721},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 366, col: 41, offset: 10726},
								expr: &seqExpr{
									pos: position{line: 366, col: 42, offset: 10727},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 366, col: 42, offset: 10727},
											name: "OR",
										},
										&ruleRefExpr{
											pos:  position{line: 366, col: 45, offset: 10730},
											name: "ClauseLevel2",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ClauseLevel2",
			pos:  position{line: 384, col: 1, offset: 11095},
			expr: &choiceExpr{
				pos: position{line: 384, col: 17, offset: 11111},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 384, col: 17, offset: 11111},
						run: (*parser).callonClauseLevel22,
						expr: &seqExpr{
							pos: position{line: 384, col: 17, offset: 11111},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 384, col: 17, offset: 11111},
									label: "notList",
									expr: &oneOrMoreExpr{
										pos: position{line: 384, col: 25, offset: 11119},
										expr: &ruleRefExpr{
											pos:  position{line: 384, col: 25, offset: 11119},
											name: "NOT",
										},
									},
								},
								&labeledExpr{
									pos:   position{line: 384, col: 30, offset: 11124},
									label: "first",
									expr: &ruleRefExpr{
										pos:  position{line: 384, col: 36, offset: 11130},
										name: "ClauseLevel1",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 395, col: 5, offset: 11426},
						run: (*parser).callonClauseLevel29,
						expr: &labeledExpr{
							pos:   position{line: 395, col: 5, offset: 11426},
							label: "clause",
							expr: &ruleRefExpr{
								pos:  position{line: 395, col: 12, offset: 11433},
								name: "ClauseLevel1",
							},
						},
					},
				},
			},
		},
		{
			name: "ClauseLevel1",
			pos:  position{line: 399, col: 1, offset: 11474},
			expr: &choiceExpr{
				pos: position{line: 399, col: 17, offset: 11490},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 399, col: 17, offset: 11490},
						run: (*parser).callonClauseLevel12,
						expr: &seqExpr{
							pos: position{line: 399, col: 17, offset: 11490},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 399, col: 17, offset: 11490},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 399, col: 25, offset: 11498},
									label: "clause",
									expr: &ruleRefExpr{
										pos:  position{line: 399, col: 32, offset: 11505},
										name: "ClauseLevel4",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 399, col: 45, offset: 11518},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 401, col: 5, offset: 11555},
						run: (*parser).callonClauseLevel18,
						expr: &labeledExpr{
							pos:   position{line: 401, col: 5, offset: 11555},
							label: "term",
							expr: &ruleRefExpr{
								pos:  position{line: 401, col: 10, offset: 11560},
								name: "SearchTerm",
							},
						},
					},
				},
			},
		},
		{
			name: "SearchTerm",
			pos:  position{line: 407, col: 1, offset: 11718},
			expr: &actionExpr{
				pos: position{line: 407, col: 15, offset: 11732},
				run: (*parser).callonSearchTerm1,
				expr: &labeledExpr{
					pos:   position{line: 407, col: 15, offset: 11732},
					label: "term",
					expr: &choiceExpr{
						pos: position{line: 407, col: 21, offset: 11738},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 407, col: 21, offset: 11738},
								name: "FieldWithNumberValue",
							},
							&ruleRefExpr{
								pos:  position{line: 407, col: 44, offset: 11761},
								name: "FieldWithBooleanValue",
							},
							&ruleRefExpr{
								pos:  position{line: 407, col: 68, offset: 11785},
								name: "FieldWithStringValue",
							},
						},
					},
				},
			},
		},
		{
			name: "TimechartBlock",
			pos:  position{line: 412, col: 1, offset: 11926},
			expr: &actionExpr{
				pos: position{line: 412, col: 19, offset: 11944},
				run: (*parser).callonTimechartBlock1,
				expr: &seqExpr{
					pos: position{line: 412, col: 19, offset: 11944},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 412, col: 19, offset: 11944},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 412, col: 24, offset: 11949},
							name: "CMD_TIMECHART",
						},
						&labeledExpr{
							pos:   position{line: 412, col: 38, offset: 11963},
							label: "tcArgs",
							expr: &ruleRefExpr{
								pos:  position{line: 412, col: 45, offset: 11970},
								name: "TimechartArgumentsList",
							},
						},
						&labeledExpr{
							pos:   position{line: 412, col: 68, offset: 11993},
							label: "limitExpr",
							expr: &zeroOrOneExpr{
								pos: position{line: 412, col: 78, offset: 12003},
								expr: &ruleRefExpr{
									pos:  position{line: 412, col: 79, offset: 12004},
									name: "LimitExpr",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "TimechartArgumentsList",
			pos:  position{line: 500, col: 1, offset: 14747},
			expr: &actionExpr{
				pos: position{line: 500, col: 27, offset: 14773},
				run: (*parser).callonTimechartArgumentsList1,
				expr: &seqExpr{
					pos: position{line: 500, col: 27, offset: 14773},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 500, col: 27, offset: 14773},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 500, col: 33, offset: 14779},
								name: "TimechartArgument",
							},
						},
						&labeledExpr{
							pos:   position{line: 500, col: 51, offset: 14797},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 500, col: 56, offset: 14802},
								expr: &seqExpr{
									pos: position{line: 500, col: 57, offset: 14803},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 500, col: 57, offset: 14803},
											name: "SPACE",
										},
										&ruleRefExpr{
											pos:  position{line: 500, col: 63, offset: 14809},
											name: "TimechartArgument",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "TimechartArgument",
			pos:  position{line: 529, col: 1, offset: 15543},
			expr: &actionExpr{
				pos: position{line: 529, col: 22, offset: 15564},
				run: (*parser).callonTimechartArgument1,
				expr: &labeledExpr{
					pos:   position{line: 529, col: 22, offset: 15564},
					label: "tcArg",
					expr: &choiceExpr{
						pos: position{line: 529, col: 29, offset: 15571},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 529, col: 29, offset: 15571},
								name: "SingleAggExpr",
							},
							&ruleRefExpr{
								pos:  position{line: 529, col: 45, offset: 15587},
								name: "TcOptions",
							},
						},
					},
				},
			},
		},
		{
			name: "SingleAggExpr",
			pos:  position{line: 533, col: 1, offset: 15625},
			expr: &actionExpr{
				pos: position{line: 533, col: 18, offset: 15642},
				run: (*parser).callonSingleAggExpr1,
				expr: &seqExpr{
					pos: position{line: 533, col: 18, offset: 15642},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 533, col: 18, offset: 15642},
							label: "aggs",
							expr: &ruleRefExpr{
								pos:  position{line: 533, col: 23, offset: 15647},
								name: "AggregationList",
							},
						},
						&labeledExpr{
							pos:   position{line: 533, col: 39, offset: 15663},
							label: "splitByClause",
							expr: &zeroOrOneExpr{
								pos: position{line: 533, col: 53, offset: 15677},
								expr: &ruleRefExpr{
									pos:  position{line: 533, col: 53, offset: 15677},
									name: "SplitByClause",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "SplitByClause",
			pos:  position{line: 547, col: 1, offset: 16016},
			expr: &actionExpr{
				pos: position{line: 547, col: 18, offset: 16033},
				run: (*parser).callonSplitByClause1,
				expr: &seqExpr{
					pos: position{line: 547, col: 18, offset: 16033},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 547, col: 18, offset: 16033},
							name: "BY",
						},
						&labeledExpr{
							pos:   position{line: 547, col: 21, offset: 16036},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 547, col: 27, offset: 16042},
								name: "FieldName",
							},
						},
					},
				},
			},
		},
		{
			name: "TcOptions",
			pos:  position{line: 555, col: 1, offset: 16171},
			expr: &actionExpr{
				pos: position{line: 555, col: 14, offset: 16184},
				run: (*parser).callonTcOptions1,
				expr: &labeledExpr{
					pos:   position{line: 555, col: 14, offset: 16184},
					label: "option",
					expr: &choiceExpr{
						pos: position{line: 555, col: 22, offset: 16192},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 555, col: 22, offset: 16192},
								name: "BinOptions",
							},
							&oneOrMoreExpr{
								pos: position{line: 555, col: 35, offset: 16205},
								expr: &ruleRefExpr{
									pos:  position{line: 555, col: 36, offset: 16206},
									name: "TcOption",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "TcOption",
			pos:  position{line: 597, col: 1, offset: 17726},
			expr: &actionExpr{
				pos: position{line: 597, col: 13, offset: 17738},
				run: (*parser).callonTcOption1,
				expr: &seqExpr{
					pos: position{line: 597, col: 13, offset: 17738},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 597, col: 13, offset: 17738},
							name: "SPACE",
						},
						&labeledExpr{
							pos:   position{line: 597, col: 19, offset: 17744},
							label: "tcOptionCMD",
							expr: &ruleRefExpr{
								pos:  position{line: 597, col: 31, offset: 17756},
								name: "TcOptionCMD",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 597, col: 43, offset: 17768},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 597, col: 49, offset: 17774},
							label: "val",
							expr: &ruleRefExpr{
								pos:  position{line: 597, col: 53, offset: 17778},
								name: "EvalFieldToRead",
							},
						},
					},
				},
			},
		},
		{
			name: "TcOptionCMD",
			pos:  position{line: 602, col: 1, offset: 17891},
			expr: &actionExpr{
				pos: position{line: 602, col: 16, offset: 17906},
				run: (*parser).callonTcOptionCMD1,
				expr: &labeledExpr{
					pos:   position{line: 602, col: 16, offset: 17906},
					label: "option",
					expr: &choiceExpr{
						pos: position{line: 602, col: 24, offset: 17914},
						alternatives: []any{
							&litMatcher{
								pos:        position{line: 602, col: 24, offset: 17914},
								val:        "usenull",
								ignoreCase: false,
								want:       "\"usenull\"",
							},
							&litMatcher{
								pos:        position{line: 602, col: 36, offset: 17926},
								val:        "useother",
								ignoreCase: false,
								want:       "\"useother\"",
							},
							&litMatcher{
								pos:        position{line: 602, col: 49, offset: 17939},
								val:        "nullstr",
								ignoreCase: false,
								want:       "\"nullstr\"",
							},
							&litMatcher{
								pos:        position{line: 602, col: 61, offset: 17951},
								val:        "otherstr",
								ignoreCase: false,
								want:       "\"otherstr\"",
							},
						},
					},
				},
			},
		},
		{
			name: "BinOptions",
			pos:  position{line: 611, col: 1, offset: 18300},
			expr: &actionExpr{
				pos: position{line: 611, col: 15, offset: 18314},
				run: (*parser).callonBinOptions1,
				expr: &labeledExpr{
					pos:   position{line: 611, col: 15, offset: 18314},
					label: "spanOptions",
					expr: &ruleRefExpr{
						pos:  position{line: 611, col: 27, offset: 18326},
						name: "SpanOptions",
					},
				},
			},
		},
		{
			name: "SpanOptions",
			pos:  position{line: 619, col: 1, offset: 18551},
			expr: &actionExpr{
				pos: position{line: 619, col: 16, offset: 18566},
				run: (*parser).callonSpanOptions1,
				expr: &seqExpr{
					pos: position{line: 619, col: 16, offset: 18566},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 619, col: 16, offset: 18566},
							name: "CMD_SPAN",
						},
						&ruleRefExpr{
							pos:  position{line: 619, col: 25, offset: 18575},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 619, col: 31, offset: 18581},
							label: "spanLength",
							expr: &ruleRefExpr{
								pos:  position{line: 619, col: 42, offset: 18592},
								name: "SpanLength",
							},
						},
					},
				},
			},
		},
		{
			name: "SpanLength",
			pos:  position{line: 626, col: 1, offset: 18738},
			expr: &actionExpr{
				pos: position{line: 626, col: 15, offset: 18752},
				run: (*parser).callonSpanLength1,
				expr: &seqExpr{
					pos: position{line: 626, col: 15, offset: 18752},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 626, col: 15, offset: 18752},
							label: "intAsStr",
							expr: &ruleRefExpr{
								pos:  position{line: 626, col: 24, offset: 18761},
								name: "IntegerAsString",
							},
						},
						&labeledExpr{
							pos:   position{line: 626, col: 40, offset: 18777},
							label: "timeScale",
							expr: &ruleRefExpr{
								pos:  position{line: 626, col: 50, offset: 18787},
								name: "TimeScale",
							},
						},
					},
				},
			},
		},
		{
			name: "TimeScale",
			pos:  position{line: 639, col: 1, offset: 19105},
			expr: &actionExpr{
				pos: position{line: 639, col: 14, offset: 19118},
				run: (*parser).callonTimeScale1,
				expr: &labeledExpr{
					pos:   position{line: 639, col: 14, offset: 19118},
					label: "timeUnit",
					expr: &choiceExpr{
						pos: position{line: 639, col: 24, offset: 19128},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 639, col: 24, offset: 19128},
								name: "Second",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 33, offset: 19137},
								name: "Minute",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 42, offset: 19146},
								name: "Hour",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 49, offset: 19153},
								name: "Day",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 54, offset: 19158},
								name: "Week",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 61, offset: 19165},
								name: "Month",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 69, offset: 19173},
								name: "Quarter",
							},
							&ruleRefExpr{
								pos:  position{line: 639, col: 78, offset: 19182},
								name: "Subseconds",
							},
						},
					},
				},
			},
		},
		{
			name: "LimitExpr",
			pos:  position{line: 644, col: 1, offset: 19304},
			expr: &actionExpr{
				pos: position{line: 644, col: 14, offset: 19317},
				run: (*parser).callonLimitExpr1,
				expr: &seqExpr{
					pos: position{line: 644, col: 14, offset: 19317},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 644, col: 14, offset: 19317},
							name: "SPACE",
						},
						&litMatcher{
							pos:        position{line: 644, col: 20, offset: 19323},
							val:        "limit",
							ignoreCase: false,
							want:       "\"limit\"",
						},
						&ruleRefExpr{
							pos:  position{line: 644, col: 28, offset: 19331},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 644, col: 34, offset: 19337},
							label: "sortBy",
							expr: &zeroOrOneExpr{
								pos: position{line: 644, col: 41, offset: 19344},
								expr: &choiceExpr{
									pos: position{line: 644, col: 42, offset: 19345},
									alternatives: []any{
										&litMatcher{
											pos:        position{line: 644, col: 42, offset: 19345},
											val:        "top",
											ignoreCase: false,
											want:       "\"top\"",
										},
										&litMatcher{
											pos:        position{line: 644, col: 50, offset: 19353},
											val:        "bottom",
											ignoreCase: false,
											want:       "\"bottom\"",
										},
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 644, col: 61, offset: 19364},
							name: "EMPTY_OR_SPACE",
						},
						&labeledExpr{
							pos:   position{line: 644, col: 76, offset: 19379},
							label: "intAsStr",
							expr: &ruleRefExpr{
								pos:  position{line: 644, col: 86, offset: 19389},
								name: "IntegerAsString",
							},
						},
					},
				},
			},
		},
		{
			name: "StatisticBlock",
			pos:  position{line: 668, col: 1, offset: 19970},
			expr: &actionExpr{
				pos: position{line: 668, col: 19, offset: 19988},
				run: (*parser).callonStatisticBlock1,
				expr: &seqExpr{
					pos: position{line: 668, col: 19, offset: 19988},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 668, col: 19, offset: 19988},
							name: "PIPE",
						},
						&labeledExpr{
							pos:   position{line: 668, col: 24, offset: 19993},
							label: "statisticExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 668, col: 38, offset: 20007},
								name: "StatisticExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "StatisticExpr",
			pos:  position{line: 701, col: 1, offset: 20985},
			expr: &actionExpr{
				pos: position{line: 701, col: 18, offset: 21002},
				run: (*parser).callonStatisticExpr1,
				expr: &seqExpr{
					pos: position{line: 701, col: 18, offset: 21002},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 701, col: 18, offset: 21002},
							label: "cmd",
							expr: &choiceExpr{
								pos: position{line: 701, col: 23, offset: 21007},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 701, col: 23, offset: 21007},
										name: "CMD_TOP",
									},
									&ruleRefExpr{
										pos:  position{line: 701, col: 33, offset: 21017},
										name: "CMD_RARE",
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 701, col: 43, offset: 21027},
							label: "limit",
							expr: &zeroOrOneExpr{
								pos: position{line: 701, col: 49, offset: 21033},
								expr: &ruleRefExpr{
									pos:  position{line: 701, col: 50, offset: 21034},
									name: "StatisticLimit",
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 701, col: 67, offset: 21051},
							label: "fieldList",
							expr: &seqExpr{
								pos: position{line: 701, col: 78, offset: 21062},
								exprs: []any{
									&ruleRefExpr{
										pos:  position{line: 701, col: 78, offset: 21062},
										name: "SPACE",
									},
									&ruleRefExpr{
										pos:  position{line: 701, col: 84, offset: 21068},
										name: "FieldNameList",
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 701, col: 99, offset: 21083},
							label: "byClause",
							expr: &zeroOrOneExpr{
								pos: position{line: 701, col: 108, offset: 21092},
								expr: &ruleRefExpr{
									pos:  position{line: 701, col: 109, offset: 21093},
									name: "ByClause",
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 701, col: 120, offset: 21104},
							label: "options",
							expr: &zeroOrOneExpr{
								pos: position{line: 701, col: 128, offset: 21112},
								expr: &ruleRefExpr{
									pos:  position{line: 701, col: 129, offset: 21113},
									name: "StatisticOptions",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "StatisticLimit",
			pos:  position{line: 743, col: 1, offset: 22198},
			expr: &choiceExpr{
				pos: position{line: 743, col: 19, offset: 22216},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 743, col: 19, offset: 22216},
						run: (*parser).callonStatisticLimit2,
						expr: &seqExpr{
							pos: position{line: 743, col: 19, offset: 22216},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 743, col: 19, offset: 22216},
									name: "SPACE",
								},
								&labeledExpr{
									pos:   position{line: 743, col: 25, offset: 22222},
									label: "number",
									expr: &ruleRefExpr{
										pos:  position{line: 743, col: 32, offset: 22229},
										name: "IntegerAsString",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 746, col: 3, offset: 22283},
						run: (*parser).callonStatisticLimit7,
						expr: &seqExpr{
							pos: position{line: 746, col: 3, offset: 22283},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 746, col: 3, offset: 22283},
									name: "SPACE",
								},
								&litMatcher{
									pos:        position{line: 746, col: 9, offset: 22289},
									val:        "limit",
									ignoreCase: false,
									want:       "\"limit\"",
								},
								&ruleRefExpr{
									pos:  position{line: 746, col: 17, offset: 22297},
									name: "EQUAL",
								},
								&labeledExpr{
									pos:   position{line: 746, col: 23, offset: 22303},
									label: "limit",
									expr: &ruleRefExpr{
										pos:  position{line: 746, col: 30, offset: 22310},
										name: "IntegerAsString",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "StatisticOptions",
			pos:  position{line: 751, col: 1, offset: 22408},
			expr: &actionExpr{
				pos: position{line: 751, col: 21, offset: 22428},
				run: (*parser).callonStatisticOptions1,
				expr: &labeledExpr{
					pos:   position{line: 751, col: 21, offset: 22428},
					label: "option",
					expr: &zeroOrMoreExpr{
						pos: position{line: 751, col: 28, offset: 22435},
						expr: &ruleRefExpr{
							pos:  position{line: 751, col: 29, offset: 22436},
							name: "StatisticOption",
						},
					},
				},
			},
		},
		{
			name: "StatisticOption",
			pos:  position{line: 800, col: 1, offset: 23998},
			expr: &actionExpr{
				pos: position{line: 800, col: 20, offset: 24017},
				run: (*parser).callonStatisticOption1,
				expr: &seqExpr{
					pos: position{line: 800, col: 20, offset: 24017},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 800, col: 20, offset: 24017},
							name: "SPACE",
						},
						&labeledExpr{
							pos:   position{line: 800, col: 26, offset: 24023},
							label: "optionCMD",
							expr: &ruleRefExpr{
								pos:  position{line: 800, col: 36, offset: 24033},
								name: "StatisticOptionCMD",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 800, col: 55, offset: 24052},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 800, col: 61, offset: 24058},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 800, col: 67, offset: 24064},
								name: "EvalFieldToRead",
							},
						},
					},
				},
			},
		},
		{
			name: "StatisticOptionCMD",
			pos:  position{line: 805, col: 1, offset: 24173},
			expr: &actionExpr{
				pos: position{line: 805, col: 23, offset: 24195},
				run: (*parser).callonStatisticOptionCMD1,
				expr: &labeledExpr{
					pos:   position{line: 805, col: 23, offset: 24195},
					label: "option",
					expr: &choiceExpr{
						pos: position{line: 805, col: 31, offset: 24203},
						alternatives: []any{
							&litMatcher{
								pos:        position{line: 805, col: 31, offset: 24203},
								val:        "countfield",
								ignoreCase: false,
								want:       "\"countfield\"",
							},
							&litMatcher{
								pos:        position{line: 805, col: 46, offset: 24218},
								val:        "showcount",
								ignoreCase: false,
								want:       "\"showcount\"",
							},
							&litMatcher{
								pos:        position{line: 805, col: 60, offset: 24232},
								val:        "otherstr",
								ignoreCase: false,
								want:       "\"otherstr\"",
							},
							&litMatcher{
								pos:        position{line: 805, col: 73, offset: 24245},
								val:        "useother",
								ignoreCase: false,
								want:       "\"useother\"",
							},
							&litMatcher{
								pos:        position{line: 805, col: 85, offset: 24257},
								val:        "percentfield",
								ignoreCase: false,
								want:       "\"percentfield\"",
							},
							&litMatcher{
								pos:        position{line: 805, col: 102, offset: 24274},
								val:        "showperc",
								ignoreCase: false,
								want:       "\"showperc\"",
							},
						},
					},
				},
			},
		},
		{
			name: "ByClause",
			pos:  position{line: 813, col: 1, offset: 24461},
			expr: &choiceExpr{
				pos: position{line: 813, col: 13, offset: 24473},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 813, col: 13, offset: 24473},
						run: (*parser).callonByClause2,
						expr: &seqExpr{
							pos: position{line: 813, col: 13, offset: 24473},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 813, col: 13, offset: 24473},
									name: "BY",
								},
								&labeledExpr{
									pos:   position{line: 813, col: 16, offset: 24476},
									label: "fieldList",
									expr: &ruleRefExpr{
										pos:  position{line: 813, col: 26, offset: 24486},
										name: "FieldNameList",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 816, col: 3, offset: 24543},
						run: (*parser).callonByClause7,
						expr: &labeledExpr{
							pos:   position{line: 816, col: 3, offset: 24543},
							label: "groupByBlock",
							expr: &ruleRefExpr{
								pos:  position{line: 816, col: 16, offset: 24556},
								name: "GroupbyBlock",
							},
						},
					},
				},
			},
		},
		{
			name: "DedupBlock",
			pos:  position{line: 820, col: 1, offset: 24614},
			expr: &actionExpr{
				pos: position{line: 820, col: 15, offset: 24628},
				run: (*parser).callonDedupBlock1,
				expr: &seqExpr{
					pos: position{line: 820, col: 15, offset: 24628},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 820, col: 15, offset: 24628},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 820, col: 20, offset: 24633},
							name: "CMD_DEDUP",
						},
						&labeledExpr{
							pos:   position{line: 820, col: 30, offset: 24643},
							label: "dedupExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 820, col: 40, offset: 24653},
								name: "DedupExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "DedupExpr",
			pos:  position{line: 840, col: 1, offset: 25221},
			expr: &actionExpr{
				pos: position{line: 840, col: 14, offset: 25234},
				run: (*parser).callonDedupExpr1,
				expr: &seqExpr{
					pos: position{line: 840, col: 14, offset: 25234},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 840, col: 14, offset: 25234},
							label: "limitArr",
							expr: &zeroOrOneExpr{
								pos: position{line: 840, col: 23, offset: 25243},
								expr: &seqExpr{
									pos: position{line: 840, col: 24, offset: 25244},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 840, col: 24, offset: 25244},
											name: "SPACE",
										},
										&ruleRefExpr{
											pos:  position{line: 840, col: 30, offset: 25250},
											name: "IntegerAsString",
										},
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 840, col: 48, offset: 25268},
							label: "options1",
							expr: &zeroOrOneExpr{
								pos: position{line: 840, col: 57, offset: 25277},
								expr: &ruleRefExpr{
									pos:  position{line: 840, col: 58, offset: 25278},
									name: "DedupOptions",
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 840, col: 73, offset: 25293},
							label: "fieldList",
							expr: &zeroOrOneExpr{
								pos: position{line: 840, col: 83, offset: 25303},
								expr: &ruleRefExpr{
									pos:  position{line: 840, col: 84, offset: 25304},
									name: "DedupFieldList",
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 840, col: 101, offset: 25321},
							label: "options2",
							expr: &zeroOrOneExpr{
								pos: position{line: 840, col: 110, offset: 25330},
								expr: &ruleRefExpr{
									pos:  position{line: 840, col: 111, offset: 25331},
									name: "DedupOptions",
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 840, col: 126, offset: 25346},
							label: "sortByClause",
							expr: &zeroOrOneExpr{
								pos: position{line: 840, col: 139, offset: 25359},
								expr: &ruleRefExpr{
									pos:  position{line: 840, col: 140, offset: 25360},
									name: "DedupSortByClause",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "DedupFieldName",
			pos:  position{line: 897, col: 1, offset: 27098},
			expr: &actionExpr{
				pos: position{line: 897, col: 19, offset: 27116},
				run: (*parser).callonDedupFieldName1,
				expr: &seqExpr{
					pos: position{line: 897, col: 19, offset: 27116},
					exprs: []any{
						&notExpr{
							pos: position{line: 897, col: 19, offset: 27116},
							expr: &litMatcher{
								pos:        position{line: 897, col: 21, offset: 27118},
								val:        "sortby",
								ignoreCase: false,
								want:       "\"sortby\"",
							},
						},
						&labeledExpr{
							pos:   position{line: 897, col: 31, offset: 27128},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 897, col: 37, offset: 27134},
								name: "FieldName",
							},
						},
					},
				},
			},
		},
		{
			name: "DedupFieldList",
			pos:  position{line: 901, col: 1, offset: 27171},
			expr: &actionExpr{
				pos: position{line: 901, col: 19, offset: 27189},
				run: (*parser).callonDedupFieldList1,
				expr: &seqExpr{
					pos: position{line: 901, col: 19, offset: 27189},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 901, col: 19, offset: 27189},
							name: "SPACE",
						},
						&labeledExpr{
							pos:   position{line: 901, col: 25, offset: 27195},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 901, col: 31, offset: 27201},
								name: "DedupFieldName",
							},
						},
						&labeledExpr{
							pos:   position{line: 901, col: 46, offset: 27216},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 901, col: 51, offset: 27221},
								expr: &seqExpr{
									pos: position{line: 901, col: 52, offset: 27222},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 901, col: 52, offset: 27222},
											name: "SPACE",
										},
										&ruleRefExpr{
											pos:  position{line: 901, col: 58, offset: 27228},
											name: "DedupFieldName",
										},
										&notExpr{
											pos: position{line: 901, col: 73, offset: 27243},
											expr: &ruleRefExpr{
												pos:  position{line: 901, col: 74, offset: 27244},
												name: "EQUAL",
											},
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "DedupOptions",
			pos:  position{line: 919, col: 1, offset: 27772},
			expr: &actionExpr{
				pos: position{line: 919, col: 17, offset: 27788},
				run: (*parser).callonDedupOptions1,
				expr: &labeledExpr{
					pos:   position{line: 919, col: 17, offset: 27788},
					label: "option",
					expr: &zeroOrMoreExpr{
						pos: position{line: 919, col: 24, offset: 27795},
						expr: &ruleRefExpr{
							pos:  position{line: 919, col: 25, offset: 27796},
							name: "DedupOption",
						},
					},
				},
			},
		},
		{
			name: "DedupOption",
			pos:  position{line: 959, col: 1, offset: 29062},
			expr: &actionExpr{
				pos: position{line: 959, col: 16, offset: 29077},
				run: (*parser).callonDedupOption1,
				expr: &seqExpr{
					pos: position{line: 959, col: 16, offset: 29077},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 959, col: 16, offset: 29077},
							name: "SPACE",
						},
						&labeledExpr{
							pos:   position{line: 959, col: 22, offset: 29083},
							label: "optionCMD",
							expr: &ruleRefExpr{
								pos:  position{line: 959, col: 32, offset: 29093},
								name: "DedupOptionCMD",
							},
						},
						&litMatcher{
							pos:        position{line: 959, col: 47, offset: 29108},
							val:        "=",
							ignoreCase: false,
							want:       "\"=\"",
						},
						&labeledExpr{
							pos:   position{line: 959, col: 51, offset: 29112},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 959, col: 57, offset: 29118},
								name: "EvalFieldToRead",
							},
						},
					},
				},
			},
		},
		{
			name: "DedupOptionCMD",
			pos:  position{line: 964, col: 1, offset: 29227},
			expr: &actionExpr{
				pos: position{line: 964, col: 19, offset: 29245},
				run: (*parser).callonDedupOptionCMD1,
				expr: &labeledExpr{
					pos:   position{line: 964, col: 19, offset: 29245},
					label: "option",
					expr: &choiceExpr{
						pos: position{line: 964, col: 27, offset: 29253},
						alternatives: []any{
							&litMatcher{
								pos:        position{line: 964, col: 27, offset: 29253},
								val:        "consecutive",
								ignoreCase: false,
								want:       "\"consecutive\"",
							},
							&litMatcher{
								pos:        position{line: 964, col: 43, offset: 29269},
								val:        "keepempty",
								ignoreCase: false,
								want:       "\"keepempty\"",
							},
							&litMatcher{
								pos:        position{line: 964, col: 57, offset: 29283},
								val:        "keepevents",
								ignoreCase: false,
								want:       "\"keepevents\"",
							},
						},
					},
				},
			},
		},
		{
			name: "DedupSortByClause",
			pos:  position{line: 972, col: 1, offset: 29468},
			expr: &actionExpr{
				pos: position{line: 972, col: 22, offset: 29489},
				run: (*parser).callonDedupSortByClause1,
				expr: &seqExpr{
					pos: position{line: 972, col: 22, offset: 29489},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 972, col: 22, offset: 29489},
							name: "CMD_DEDUP_SORTBY",
						},
						&labeledExpr{
							pos:   position{line: 972, col: 39, offset: 29506},
							label: "dedupSortEles",
							expr: &ruleRefExpr{
								pos:  position{line: 972, col: 53, offset: 29520},
								name: "SortElements",
							},
						},
					},
				},
			},
		},
		{
			name: "SortElements",
			pos:  position{line: 977, col: 1, offset: 29628},
			expr: &actionExpr{
				pos: position{line: 977, col: 17, offset: 29644},
				run: (*parser).callonSortElements1,
				expr: &seqExpr{
					pos: position{line: 977, col: 17, offset: 29644},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 977, col: 17, offset: 29644},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 977, col: 23, offset: 29650},
								name: "SingleSortElement",
							},
						},
						&labeledExpr{
							pos:   position{line: 977, col: 41, offset: 29668},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 977, col: 46, offset: 29673},
								expr: &seqExpr{
									pos: position{line: 977, col: 47, offset: 29674},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 977, col: 47, offset: 29674},
											name: "EMPTY_OR_COMMA",
										},
										&ruleRefExpr{
											pos:  position{line: 977, col: 62, offset: 29689},
											name: "SingleSortElement",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "SingleSortElement",
			pos:  position{line: 992, col: 1, offset: 30047},
			expr: &actionExpr{
				pos: position{line: 992, col: 22, offset: 30068},
				run: (*parser).callonSingleSortElement1,
				expr: &labeledExpr{
					pos:   position{line: 992, col: 22, offset: 30068},
					label: "element",
					expr: &choiceExpr{
						pos: position{line: 992, col: 31, offset: 30077},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 992, col: 31, offset: 30077},
								name: "SingleSortElementWithCast",
							},
							&ruleRefExpr{
								pos:  position{line: 992, col: 59, offset: 30105},
								name: "SingleSortElementWithoutCast",
							},
						},
					},
				},
			},
		},
		{
			name: "SingleSortElementWithoutCast",
			pos:  position{line: 996, col: 1, offset: 30164},
			expr: &actionExpr{
				pos: position{line: 996, col: 33, offset: 30196},
				run: (*parser).callonSingleSortElementWithoutCast1,
				expr: &seqExpr{
					pos: position{line: 996, col: 33, offset: 30196},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 996, col: 33, offset: 30196},
							label: "sortBySymbol",
							expr: &choiceExpr{
								pos: position{line: 996, col: 47, offset: 30210},
								alternatives: []any{
									&litMatcher{
										pos:        position{line: 996, col: 47, offset: 30210},
										val:        "+",
										ignoreCase: false,
										want:       "\"+\"",
									},
									&litMatcher{
										pos:        position{line: 996, col: 53, offset: 30216},
										val:        "-",
										ignoreCase: false,
										want:       "\"-\"",
									},
									&litMatcher{
										pos:        position{line: 996, col: 59, offset: 30222},
										val:        "",
										ignoreCase: false,
										want:       "\"\"",
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 996, col: 63, offset: 30226},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 996, col: 69, offset: 30232},
								name: "FieldName",
							},
						},
					},
				},
			},
		},
		{
			name: "SingleSortElementWithCast",
			pos:  position{line: 1011, col: 1, offset: 30507},
			expr: &actionExpr{
				pos: position{line: 1011, col: 30, offset: 30536},
				run: (*parser).callonSingleSortElementWithCast1,
				expr: &seqExpr{
					pos: position{line: 1011, col: 30, offset: 30536},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1011, col: 30, offset: 30536},
							label: "sortBySymbol",
							expr: &choiceExpr{
								pos: position{line: 1011, col: 44, offset: 30550},
								alternatives: []any{
									&litMatcher{
										pos:        position{line: 1011, col: 44, offset: 30550},
										val:        "+",
										ignoreCase: false,
										want:       "\"+\"",
									},
									&litMatcher{
										pos:        position{line: 1011, col: 50, offset: 30556},
										val:        "-",
										ignoreCase: false,
										want:       "\"-\"",
									},
									&litMatcher{
										pos:        position{line: 1011, col: 56, offset: 30562},
										val:        "",
										ignoreCase: false,
										want:       "\"\"",
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 1011, col: 60, offset: 30566},
							label: "op",
							expr: &choiceExpr{
								pos: position{line: 1011, col: 64, offset: 30570},
								alternatives: []any{
									&litMatcher{
										pos:        position{line: 1011, col: 64, offset: 30570},
										val:        "auto",
										ignoreCase: false,
										want:       "\"auto\"",
									},
									&litMatcher{
										pos:        position{line: 1011, col: 73, offset: 30579},
										val:        "str",
										ignoreCase: false,
										want:       "\"str\"",
									},
									&litMatcher{
										pos:        position{line: 1011, col: 81, offset: 30587},
										val:        "ip",
										ignoreCase: false,
										want:       "\"ip\"",
									},
									&litMatcher{
										pos:        position{line: 1011, col: 88, offset: 30594},
										val:        "num",
										ignoreCase: false,
										want:       "\"num\"",
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1011, col: 95, offset: 30601},
							name: "L_PAREN",
						},
						&labeledExpr{
							pos:   position{line: 1011, col: 103, offset: 30609},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 1011, col: 109, offset: 30615},
								name: "FieldName",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1011, col: 119, offset: 30625},
							name: "R_PAREN",
						},
					},
				},
			},
		},
		{
			name: "RenameBlock",
			pos:  position{line: 1031, col: 1, offset: 31050},
			expr: &actionExpr{
				pos: position{line: 1031, col: 16, offset: 31065},
				run: (*parser).callonRenameBlock1,
				expr: &seqExpr{
					pos: position{line: 1031, col: 16, offset: 31065},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1031, col: 16, offset: 31065},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 1031, col: 21, offset: 31070},
							name: "CMD_RENAME",
						},
						&labeledExpr{
							pos:   position{line: 1031, col: 32, offset: 31081},
							label: "renameExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 1031, col: 43, offset: 31092},
								name: "RenameExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "RenameExpr",
			pos:  position{line: 1047, col: 1, offset: 31467},
			expr: &choiceExpr{
				pos: position{line: 1047, col: 15, offset: 31481},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1047, col: 15, offset: 31481},
						run: (*parser).callonRenameExpr2,
						expr: &seqExpr{
							pos: position{line: 1047, col: 15, offset: 31481},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1047, col: 15, offset: 31481},
									label: "originalPattern",
									expr: &ruleRefExpr{
										pos:  position{line: 1047, col: 31, offset: 31497},
										name: "RenamePattern",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1047, col: 45, offset: 31511},
									name: "AS",
								},
								&labeledExpr{
									pos:   position{line: 1047, col: 48, offset: 31514},
									label: "newPattern",
									expr: &ruleRefExpr{
										pos:  position{line: 1047, col: 59, offset: 31525},
										name: "QuotedString",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1058, col: 3, offset: 31844},
						run: (*parser).callonRenameExpr9,
						expr: &seqExpr{
							pos: position{line: 1058, col: 3, offset: 31844},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1058, col: 3, offset: 31844},
									label: "originalPattern",
									expr: &ruleRefExpr{
										pos:  position{line: 1058, col: 19, offset: 31860},
										name: "RenamePattern",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1058, col: 33, offset: 31874},
									name: "AS",
								},
								&labeledExpr{
									pos:   position{line: 1058, col: 36, offset: 31877},
									label: "newPattern",
									expr: &ruleRefExpr{
										pos:  position{line: 1058, col: 47, offset: 31888},
										name: "RenamePattern",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "RexBlock",
			pos:  position{line: 1080, col: 1, offset: 32454},
			expr: &actionExpr{
				pos: position{line: 1080, col: 13, offset: 32466},
				run: (*parser).callonRexBlock1,
				expr: &seqExpr{
					pos: position{line: 1080, col: 13, offset: 32466},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1080, col: 13, offset: 32466},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 1080, col: 18, offset: 32471},
							name: "CMD_REX",
						},
						&litMatcher{
							pos:        position{line: 1080, col: 26, offset: 32479},
							val:        "field",
							ignoreCase: false,
							want:       "\"field\"",
						},
						&ruleRefExpr{
							pos:  position{line: 1080, col: 34, offset: 32487},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 1080, col: 40, offset: 32493},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 1080, col: 46, offset: 32499},
								name: "EvalFieldToRead",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1080, col: 62, offset: 32515},
							name: "SPACE",
						},
						&labeledExpr{
							pos:   position{line: 1080, col: 68, offset: 32521},
							label: "str",
							expr: &ruleRefExpr{
								pos:  position{line: 1080, col: 72, offset: 32525},
								name: "QuotedString",
							},
						},
					},
				},
			},
		},
		{
			name: "SortBlock",
			pos:  position{line: 1108, col: 1, offset: 33228},
			expr: &actionExpr{
				pos: position{line: 1108, col: 14, offset: 33241},
				run: (*parser).callonSortBlock1,
				expr: &seqExpr{
					pos: position{line: 1108, col: 14, offset: 33241},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1108, col: 14, offset: 33241},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 1108, col: 19, offset: 33246},
							name: "CMD_SORT",
						},
						&labeledExpr{
							pos:   position{line: 1108, col: 28, offset: 33255},
							label: "sortByEles",
							expr: &ruleRefExpr{
								pos:  position{line: 1108, col: 39, offset: 33266},
								name: "SortElements",
							},
						},
					},
				},
			},
		},
		{
			name: "EvalBlock",
			pos:  position{line: 1141, col: 1, offset: 34063},
			expr: &actionExpr{
				pos: position{line: 1141, col: 14, offset: 34076},
				run: (*parser).callonEvalBlock1,
				expr: &seqExpr{
					pos: position{line: 1141, col: 14, offset: 34076},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1141, col: 14, offset: 34076},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 1141, col: 19, offset: 34081},
							name: "CMD_EVAL",
						},
						&labeledExpr{
							pos:   position{line: 1141, col: 28, offset: 34090},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1141, col: 34, offset: 34096},
								name: "SingleEval",
							},
						},
						&labeledExpr{
							pos:   position{line: 1141, col: 45, offset: 34107},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1141, col: 50, offset: 34112},
								expr: &seqExpr{
									pos: position{line: 1141, col: 51, offset: 34113},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 1141, col: 51, offset: 34113},
											name: "COMMA",
										},
										&ruleRefExpr{
											pos:  position{line: 1141, col: 57, offset: 34119},
											name: "SingleEval",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "SingleEval",
			pos:  position{line: 1168, col: 1, offset: 34920},
			expr: &actionExpr{
				pos: position{line: 1168, col: 15, offset: 34934},
				run: (*parser).callonSingleEval1,
				expr: &seqExpr{
					pos: position{line: 1168, col: 15, offset: 34934},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1168, col: 15, offset: 34934},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 1168, col: 21, offset: 34940},
								name: "FieldName",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1168, col: 31, offset: 34950},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 1168, col: 37, offset: 34956},
							label: "expr",
							expr: &ruleRefExpr{
								pos:  position{line: 1168, col: 42, offset: 34961},
								name: "EvalExpression",
							},
						},
					},
				},
			},
		},
		{
			name: "EvalExpression",
			pos:  position{line: 1181, col: 1, offset: 35362},
			expr: &actionExpr{
				pos: position{line: 1181, col: 19, offset: 35380},
				run: (*parser).callonEvalExpression1,
				expr: &labeledExpr{
					pos:   position{line: 1181, col: 19, offset: 35380},
					label: "value",
					expr: &ruleRefExpr{
						pos:  position{line: 1181, col: 25, offset: 35386},
						name: "ValueExpr",
					},
				},
			},
		},
		{
			name: "ConditionExpr",
			pos:  position{line: 1189, col: 1, offset: 35533},
			expr: &actionExpr{
				pos: position{line: 1189, col: 18, offset: 35550},
				run: (*parser).callonConditionExpr1,
				expr: &seqExpr{
					pos: position{line: 1189, col: 18, offset: 35550},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 1189, col: 18, offset: 35550},
							val:        "if",
							ignoreCase: false,
							want:       "\"if\"",
						},
						&ruleRefExpr{
							pos:  position{line: 1189, col: 23, offset: 35555},
							name: "L_PAREN",
						},
						&labeledExpr{
							pos:   position{line: 1189, col: 31, offset: 35563},
							label: "condition",
							expr: &ruleRefExpr{
								pos:  position{line: 1189, col: 41, offset: 35573},
								name: "BoolExpr",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1189, col: 50, offset: 35582},
							name: "COMMA",
						},
						&labeledExpr{
							pos:   position{line: 1189, col: 56, offset: 35588},
							label: "trueValue",
							expr: &ruleRefExpr{
								pos:  position{line: 1189, col: 66, offset: 35598},
								name: "ValueExpr",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1189, col: 76, offset: 35608},
							name: "COMMA",
						},
						&labeledExpr{
							pos:   position{line: 1189, col: 82, offset: 35614},
							label: "falseValue",
							expr: &ruleRefExpr{
								pos:  position{line: 1189, col: 93, offset: 35625},
								name: "ValueExpr",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 1189, col: 103, offset: 35635},
							name: "R_PAREN",
						},
					},
				},
			},
		},
		{
			name: "TextExpr",
			pos:  position{line: 1201, col: 1, offset: 35885},
			expr: &choiceExpr{
				pos: position{line: 1201, col: 13, offset: 35897},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1201, col: 13, offset: 35897},
						run: (*parser).callonTextExpr2,
						expr: &seqExpr{
							pos: position{line: 1201, col: 14, offset: 35898},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1201, col: 14, offset: 35898},
									label: "opName",
									expr: &litMatcher{
										pos:        position{line: 1201, col: 22, offset: 35906},
										val:        "lower",
										ignoreCase: false,
										want:       "\"lower\"",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1201, col: 31, offset: 35915},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1201, col: 39, offset: 35923},
									label: "stringExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 1201, col: 50, offset: 35934},
										name: "StringExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1201, col: 61, offset: 35945},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1215, col: 3, offset: 36257},
						run: (*parser).callonTextExpr10,
						expr: &seqExpr{
							pos: position{line: 1215, col: 4, offset: 36258},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1215, col: 4, offset: 36258},
									label: "opName",
									expr: &choiceExpr{
										pos: position{line: 1215, col: 12, offset: 36266},
										alternatives: []any{
											&litMatcher{
												pos:        position{line: 1215, col: 12, offset: 36266},
												val:        "max",
												ignoreCase: false,
												want:       "\"max\"",
											},
											&litMatcher{
												pos:        position{line: 1215, col: 20, offset: 36274},
												val:        "min",
												ignoreCase: false,
												want:       "\"min\"",
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1215, col: 27, offset: 36281},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1215, col: 35, offset: 36289},
									label: "firstVal",
									expr: &ruleRefExpr{
										pos:  position{line: 1215, col: 44, offset: 36298},
										name: "StringExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1215, col: 55, offset: 36309},
									label: "rest",
									expr: &zeroOrMoreExpr{
										pos: position{line: 1215, col: 60, offset: 36314},
										expr: &seqExpr{
											pos: position{line: 1215, col: 61, offset: 36315},
											exprs: []any{
												&ruleRefExpr{
													pos:  position{line: 1215, col: 61, offset: 36315},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1215, col: 67, offset: 36321},
													name: "StringExpr",
												},
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1215, col: 80, offset: 36334},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1238, col: 3, offset: 37025},
						run: (*parser).callonTextExpr25,
						expr: &seqExpr{
							pos: position{line: 1238, col: 4, offset: 37026},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1238, col: 4, offset: 37026},
									label: "opName",
									expr: &litMatcher{
										pos:        position{line: 1238, col: 12, offset: 37034},
										val:        "urldecode",
										ignoreCase: false,
										want:       "\"urldecode\"",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1238, col: 25, offset: 37047},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1238, col: 33, offset: 37055},
									label: "url",
									expr: &ruleRefExpr{
										pos:  position{line: 1238, col: 37, offset: 37059},
										name: "StringExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1238, col: 48, offset: 37070},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1250, col: 3, offset: 37409},
						run: (*parser).callonTextExpr33,
						expr: &seqExpr{
							pos: position{line: 1250, col: 4, offset: 37410},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1250, col: 4, offset: 37410},
									label: "opName",
									expr: &litMatcher{
										pos:        position{line: 1250, col: 12, offset: 37418},
										val:        "split",
										ignoreCase: false,
										want:       "\"split\"",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1250, col: 21, offset: 37427},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1250, col: 29, offset: 37435},
									label: "stringExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 1250, col: 40, offset: 37446},
										name: "StringExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1250, col: 51, offset: 37457},
									name: "COMMA",
								},
								&labeledExpr{
									pos:   position{line: 1250, col: 57, offset: 37463},
									label: "delim",
									expr: &ruleRefExpr{
										pos:  position{line: 1250, col: 63, offset: 37469},
										name: "StringExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1250, col: 74, offset: 37480},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1262, col: 3, offset: 37813},
						run: (*parser).callonTextExpr44,
						expr: &seqExpr{
							pos: position{line: 1262, col: 4, offset: 37814},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1262, col: 4, offset: 37814},
									label: "opName",
									expr: &litMatcher{
										pos:        position{line: 1262, col: 12, offset: 37822},
										val:        "substr",
										ignoreCase: false,
										want:       "\"substr\"",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1262, col: 22, offset: 37832},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1262, col: 30, offset: 37840},
									label: "stringExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 1262, col: 41, offset: 37851},
										name: "StringExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1262, col: 52, offset: 37862},
									name: "COMMA",
								},
								&labeledExpr{
									pos:   position{line: 1262, col: 58, offset: 37868},
									label: "startIndex",
									expr: &ruleRefExpr{
										pos:  position{line: 1262, col: 69, offset: 37879},
										name: "NumericExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1262, col: 81, offset: 37891},
									label: "lengthParam",
									expr: &zeroOrOneExpr{
										pos: position{line: 1262, col: 93, offset: 37903},
										expr: &seqExpr{
											pos: position{line: 1262, col: 94, offset: 37904},
											exprs: []any{
												&ruleRefExpr{
													pos:  position{line: 1262, col: 94, offset: 37904},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1262, col: 100, offset: 37910},
													name: "NumericExpr",
												},
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1262, col: 114, offset: 37924},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1295, col: 3, offset: 39101},
						run: (*parser).callonTextExpr60,
						expr: &seqExpr{
							pos: position{line: 1295, col: 3, offset: 39101},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1295, col: 3, offset: 39101},
									val:        "tostring",
									ignoreCase: false,
									want:       "\"tostring\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1295, col: 14, offset: 39112},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1295, col: 22, offset: 39120},
									label: "value",
									expr: &ruleRefExpr{
										pos:  position{line: 1295, col: 28, offset: 39126},
										name: "ValueExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1295, col: 38, offset: 39136},
									label: "format",
									expr: &zeroOrOneExpr{
										pos: position{line: 1295, col: 45, offset: 39143},
										expr: &seqExpr{
											pos: position{line: 1295, col: 46, offset: 39144},
											exprs: []any{
												&ruleRefExpr{
													pos:  position{line: 1295, col: 46, offset: 39144},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1295, col: 52, offset: 39150},
													name: "StringExpr",
												},
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1295, col: 66, offset: 39164},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1308, col: 3, offset: 39533},
						run: (*parser).callonTextExpr72,
						expr: &seqExpr{
							pos: position{line: 1308, col: 4, offset: 39534},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1308, col: 4, offset: 39534},
									label: "opName",
									expr: &choiceExpr{
										pos: position{line: 1308, col: 12, offset: 39542},
										alternatives: []any{
											&litMatcher{
												pos:        position{line: 1308, col: 12, offset: 39542},
												val:        "ltrim",
												ignoreCase: false,
												want:       "\"ltrim\"",
											},
											&litMatcher{
												pos:        position{line: 1308, col: 22, offset: 39552},
												val:        "rtrim",
												ignoreCase: false,
												want:       "\"rtrim\"",
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1308, col: 31, offset: 39561},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1308, col: 39, offset: 39569},
									label: "expr",
									expr: &ruleRefExpr{
										pos:  position{line: 1308, col: 45, offset: 39575},
										name: "StringExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1308, col: 57, offset: 39587},
									label: "strToRemoveExpr",
									expr: &zeroOrOneExpr{
										pos: position{line: 1308, col: 73, offset: 39603},
										expr: &ruleRefExpr{
											pos:  position{line: 1308, col: 74, offset: 39604},
											name: "StrToRemoveExpr",
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1308, col: 92, offset: 39622},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "StrToRemoveExpr",
			pos:  position{line: 1333, col: 1, offset: 40221},
			expr: &actionExpr{
				pos: position{line: 1333, col: 20, offset: 40240},
				run: (*parser).callonStrToRemoveExpr1,
				expr: &seqExpr{
					pos: position{line: 1333, col: 20, offset: 40240},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1333, col: 20, offset: 40240},
							name: "COMMA",
						},
						&labeledExpr{
							pos:   position{line: 1333, col: 26, offset: 40246},
							label: "strToRemove",
							expr: &ruleRefExpr{
								pos:  position{line: 1333, col: 38, offset: 40258},
								name: "String",
							},
						},
					},
				},
			},
		},
		{
			name: "EvalFieldToRead",
			pos:  position{line: 1339, col: 1, offset: 40443},
			expr: &choiceExpr{
				pos: position{line: 1339, col: 20, offset: 40462},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1339, col: 20, offset: 40462},
						run: (*parser).callonEvalFieldToRead2,
						expr: &seqExpr{
							pos: position{line: 1339, col: 20, offset: 40462},
							exprs: []any{
								&oneOrMoreExpr{
									pos: position{line: 1339, col: 20, offset: 40462},
									expr: &charClassMatcher{
										pos:        position{line: 1339, col: 20, offset: 40462},
										val:        "[a-zA-Z_]",
										chars:      []rune{'_'},
										ranges:     []rune{'a', 'z', 'A', 'Z'},
										ignoreCase: false,
										inverted:   false,
									},
								},
								&notExpr{
									pos: position{line: 1339, col: 31, offset: 40473},
									expr: &litMatcher{
										pos:        position{line: 1339, col: 33, offset: 40475},
										val:        "(",
										ignoreCase: false,
										want:       "\"(\"",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1342, col: 3, offset: 40517},
						run: (*parser).callonEvalFieldToRead8,
						expr: &seqExpr{
							pos: position{line: 1342, col: 3, offset: 40517},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1342, col: 3, offset: 40517},
									val:        "'",
									ignoreCase: false,
									want:       "\"'\"",
								},
								&labeledExpr{
									pos:   position{line: 1342, col: 7, offset: 40521},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 1342, col: 13, offset: 40527},
										name: "FieldName",
									},
								},
								&litMatcher{
									pos:        position{line: 1342, col: 23, offset: 40537},
									val:        "'",
									ignoreCase: false,
									want:       "\"'\"",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "WhereBlock",
			pos:  position{line: 1347, col: 1, offset: 40605},
			expr: &actionExpr{
				pos: position{line: 1347, col: 15, offset: 40619},
				run: (*parser).callonWhereBlock1,
				expr: &seqExpr{
					pos: position{line: 1347, col: 15, offset: 40619},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1347, col: 15, offset: 40619},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 1347, col: 20, offset: 40624},
							name: "CMD_WHERE",
						},
						&labeledExpr{
							pos:   position{line: 1347, col: 30, offset: 40634},
							label: "condition",
							expr: &ruleRefExpr{
								pos:  position{line: 1347, col: 40, offset: 40644},
								name: "BoolExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "BoolExpr",
			pos:  position{line: 1359, col: 1, offset: 40937},
			expr: &actionExpr{
				pos: position{line: 1359, col: 13, offset: 40949},
				run: (*parser).callonBoolExpr1,
				expr: &labeledExpr{
					pos:   position{line: 1359, col: 13, offset: 40949},
					label: "expr",
					expr: &ruleRefExpr{
						pos:  position{line: 1359, col: 18, offset: 40954},
						name: "BoolExprLevel4",
					},
				},
			},
		},
		{
			name: "BoolExprLevel4",
			pos:  position{line: 1364, col: 1, offset: 41024},
			expr: &actionExpr{
				pos: position{line: 1364, col: 19, offset: 41042},
				run: (*parser).callonBoolExprLevel41,
				expr: &seqExpr{
					pos: position{line: 1364, col: 19, offset: 41042},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1364, col: 19, offset: 41042},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1364, col: 25, offset: 41048},
								name: "BoolExprLevel3",
							},
						},
						&labeledExpr{
							pos:   position{line: 1364, col: 40, offset: 41063},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1364, col: 45, offset: 41068},
								expr: &seqExpr{
									pos: position{line: 1364, col: 46, offset: 41069},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 1364, col: 46, offset: 41069},
											name: "OR",
										},
										&ruleRefExpr{
											pos:  position{line: 1364, col: 49, offset: 41072},
											name: "BoolExprLevel3",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "BoolExprLevel3",
			pos:  position{line: 1384, col: 1, offset: 41510},
			expr: &actionExpr{
				pos: position{line: 1384, col: 19, offset: 41528},
				run: (*parser).callonBoolExprLevel31,
				expr: &seqExpr{
					pos: position{line: 1384, col: 19, offset: 41528},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1384, col: 19, offset: 41528},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1384, col: 25, offset: 41534},
								name: "BoolExprLevel2",
							},
						},
						&labeledExpr{
							pos:   position{line: 1384, col: 40, offset: 41549},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1384, col: 45, offset: 41554},
								expr: &seqExpr{
									pos: position{line: 1384, col: 46, offset: 41555},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 1384, col: 46, offset: 41555},
											name: "AND",
										},
										&ruleRefExpr{
											pos:  position{line: 1384, col: 50, offset: 41559},
											name: "BoolExprLevel2",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "BoolExprLevel2",
			pos:  position{line: 1404, col: 1, offset: 41998},
			expr: &choiceExpr{
				pos: position{line: 1404, col: 19, offset: 42016},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1404, col: 19, offset: 42016},
						run: (*parser).callonBoolExprLevel22,
						expr: &seqExpr{
							pos: position{line: 1404, col: 19, offset: 42016},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1404, col: 19, offset: 42016},
									name: "NOT",
								},
								&ruleRefExpr{
									pos:  position{line: 1404, col: 23, offset: 42020},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1404, col: 31, offset: 42028},
									label: "first",
									expr: &ruleRefExpr{
										pos:  position{line: 1404, col: 37, offset: 42034},
										name: "BoolExprLevel1",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1404, col: 52, offset: 42049},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1414, col: 3, offset: 42252},
						run: (*parser).callonBoolExprLevel29,
						expr: &labeledExpr{
							pos:   position{line: 1414, col: 3, offset: 42252},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1414, col: 9, offset: 42258},
								name: "BoolExprLevel1",
							},
						},
					},
				},
			},
		},
		{
			name: "BoolExprLevel1",
			pos:  position{line: 1419, col: 1, offset: 42329},
			expr: &choiceExpr{
				pos: position{line: 1419, col: 19, offset: 42347},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1419, col: 19, offset: 42347},
						run: (*parser).callonBoolExprLevel12,
						expr: &seqExpr{
							pos: position{line: 1419, col: 19, offset: 42347},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1419, col: 19, offset: 42347},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1419, col: 27, offset: 42355},
									label: "first",
									expr: &ruleRefExpr{
										pos:  position{line: 1419, col: 33, offset: 42361},
										name: "BoolExprLevel4",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1419, col: 48, offset: 42376},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1422, col: 3, offset: 42412},
						run: (*parser).callonBoolExprLevel18,
						expr: &seqExpr{
							pos: position{line: 1422, col: 4, offset: 42413},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1422, col: 4, offset: 42413},
									label: "op",
									expr: &choiceExpr{
										pos: position{line: 1422, col: 8, offset: 42417},
										alternatives: []any{
											&litMatcher{
												pos:        position{line: 1422, col: 8, offset: 42417},
												val:        "isbool",
												ignoreCase: false,
												want:       "\"isbool\"",
											},
											&litMatcher{
												pos:        position{line: 1422, col: 19, offset: 42428},
												val:        "isint",
												ignoreCase: false,
												want:       "\"isint\"",
											},
											&litMatcher{
												pos:        position{line: 1422, col: 29, offset: 42438},
												val:        "isstr",
												ignoreCase: false,
												want:       "\"isstr\"",
											},
											&litMatcher{
												pos:        position{line: 1422, col: 39, offset: 42448},
												val:        "isnull",
												ignoreCase: false,
												want:       "\"isnull\"",
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1422, col: 49, offset: 42458},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1422, col: 57, offset: 42466},
									label: "value",
									expr: &ruleRefExpr{
										pos:  position{line: 1422, col: 63, offset: 42472},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1422, col: 73, offset: 42482},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1435, col: 3, offset: 42818},
						run: (*parser).callonBoolExprLevel120,
						expr: &labeledExpr{
							pos:   position{line: 1435, col: 3, offset: 42818},
							label: "likeExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 1435, col: 13, offset: 42828},
								name: "LikeExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "LikeExpr",
			pos:  position{line: 1438, col: 1, offset: 42866},
			expr: &choiceExpr{
				pos: position{line: 1438, col: 13, offset: 42878},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1438, col: 13, offset: 42878},
						run: (*parser).callonLikeExpr2,
						expr: &seqExpr{
							pos: position{line: 1438, col: 13, offset: 42878},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1438, col: 13, offset: 42878},
									label: "left",
									expr: &ruleRefExpr{
										pos:  position{line: 1438, col: 18, offset: 42883},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1438, col: 28, offset: 42893},
									name: "SPACE",
								},
								&litMatcher{
									pos:        position{line: 1438, col: 34, offset: 42899},
									val:        "LIKE",
									ignoreCase: false,
									want:       "\"LIKE\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1438, col: 41, offset: 42906},
									name: "SPACE",
								},
								&labeledExpr{
									pos:   position{line: 1438, col: 47, offset: 42912},
									label: "right",
									expr: &ruleRefExpr{
										pos:  position{line: 1438, col: 53, offset: 42918},
										name: "ValueExpr",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1447, col: 3, offset: 43138},
						run: (*parser).callonLikeExpr11,
						expr: &seqExpr{
							pos: position{line: 1447, col: 3, offset: 43138},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1447, col: 3, offset: 43138},
									val:        "like",
									ignoreCase: false,
									want:       "\"like\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1447, col: 10, offset: 43145},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1447, col: 18, offset: 43153},
									label: "stringr",
									expr: &ruleRefExpr{
										pos:  position{line: 1447, col: 26, offset: 43161},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1447, col: 36, offset: 43171},
									name: "COMMA",
								},
								&labeledExpr{
									pos:   position{line: 1447, col: 42, offset: 43177},
									label: "pattern",
									expr: &ruleRefExpr{
										pos:  position{line: 1447, col: 50, offset: 43185},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1447, col: 60, offset: 43195},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1456, col: 3, offset: 43426},
						run: (*parser).callonLikeExpr21,
						expr: &seqExpr{
							pos: position{line: 1456, col: 3, offset: 43426},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1456, col: 3, offset: 43426},
									val:        "match",
									ignoreCase: false,
									want:       "\"match\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1456, col: 11, offset: 43434},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1456, col: 19, offset: 43442},
									label: "stringVal",
									expr: &ruleRefExpr{
										pos:  position{line: 1456, col: 29, offset: 43452},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1456, col: 39, offset: 43462},
									name: "COMMA",
								},
								&labeledExpr{
									pos:   position{line: 1456, col: 45, offset: 43468},
									label: "pattern",
									expr: &ruleRefExpr{
										pos:  position{line: 1456, col: 53, offset: 43476},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1456, col: 63, offset: 43486},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1465, col: 3, offset: 43720},
						run: (*parser).callonLikeExpr31,
						expr: &seqExpr{
							pos: position{line: 1465, col: 3, offset: 43720},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1465, col: 3, offset: 43720},
									val:        "cidrmatch",
									ignoreCase: false,
									want:       "\"cidrmatch\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1465, col: 15, offset: 43732},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1465, col: 23, offset: 43740},
									label: "cidr",
									expr: &ruleRefExpr{
										pos:  position{line: 1465, col: 28, offset: 43745},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1465, col: 38, offset: 43755},
									name: "COMMA",
								},
								&labeledExpr{
									pos:   position{line: 1465, col: 44, offset: 43761},
									label: "ip",
									expr: &ruleRefExpr{
										pos:  position{line: 1465, col: 47, offset: 43764},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1465, col: 57, offset: 43774},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1474, col: 3, offset: 43994},
						run: (*parser).callonLikeExpr41,
						expr: &labeledExpr{
							pos:   position{line: 1474, col: 3, offset: 43994},
							label: "inExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 1474, col: 11, offset: 44002},
								name: "InExpr",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1477, col: 3, offset: 44038},
						run: (*parser).callonLikeExpr44,
						expr: &labeledExpr{
							pos:   position{line: 1477, col: 3, offset: 44038},
							label: "boolComparisonExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 1477, col: 22, offset: 44057},
								name: "BoolComparisonExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "BoolComparisonExpr",
			pos:  position{line: 1481, col: 1, offset: 44116},
			expr: &actionExpr{
				pos: position{line: 1481, col: 23, offset: 44138},
				run: (*parser).callonBoolComparisonExpr1,
				expr: &seqExpr{
					pos: position{line: 1481, col: 23, offset: 44138},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1481, col: 23, offset: 44138},
							label: "left",
							expr: &ruleRefExpr{
								pos:  position{line: 1481, col: 28, offset: 44143},
								name: "ValueExpr",
							},
						},
						&labeledExpr{
							pos:   position{line: 1481, col: 38, offset: 44153},
							label: "op",
							expr: &ruleRefExpr{
								pos:  position{line: 1481, col: 41, offset: 44156},
								name: "EqualityOrInequality",
							},
						},
						&labeledExpr{
							pos:   position{line: 1481, col: 62, offset: 44177},
							label: "right",
							expr: &ruleRefExpr{
								pos:  position{line: 1481, col: 68, offset: 44183},
								name: "ValueExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "InExpr",
			pos:  position{line: 1493, col: 1, offset: 44409},
			expr: &choiceExpr{
				pos: position{line: 1493, col: 11, offset: 44419},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1493, col: 11, offset: 44419},
						run: (*parser).callonInExpr2,
						expr: &seqExpr{
							pos: position{line: 1493, col: 11, offset: 44419},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1493, col: 11, offset: 44419},
									label: "left",
									expr: &ruleRefExpr{
										pos:  position{line: 1493, col: 16, offset: 44424},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1493, col: 26, offset: 44434},
									name: "SPACE",
								},
								&litMatcher{
									pos:        position{line: 1493, col: 32, offset: 44440},
									val:        "in",
									ignoreCase: false,
									want:       "\"in\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1493, col: 37, offset: 44445},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1493, col: 45, offset: 44453},
									label: "valueToJudge",
									expr: &ruleRefExpr{
										pos:  position{line: 1493, col: 58, offset: 44466},
										name: "ValueExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1493, col: 68, offset: 44476},
									label: "rest",
									expr: &zeroOrMoreExpr{
										pos: position{line: 1493, col: 73, offset: 44481},
										expr: &seqExpr{
											pos: position{line: 1493, col: 74, offset: 44482},
											exprs: []any{
												&ruleRefExpr{
													pos:  position{line: 1493, col: 74, offset: 44482},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1493, col: 80, offset: 44488},
													name: "ValueExpr",
												},
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1493, col: 92, offset: 44500},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1512, col: 3, offset: 45051},
						run: (*parser).callonInExpr17,
						expr: &seqExpr{
							pos: position{line: 1512, col: 3, offset: 45051},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1512, col: 3, offset: 45051},
									val:        "in",
									ignoreCase: false,
									want:       "\"in\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1512, col: 8, offset: 45056},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1512, col: 16, offset: 45064},
									label: "valueToJudge",
									expr: &ruleRefExpr{
										pos:  position{line: 1512, col: 29, offset: 45077},
										name: "ValueExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1512, col: 39, offset: 45087},
									label: "rest",
									expr: &zeroOrMoreExpr{
										pos: position{line: 1512, col: 44, offset: 45092},
										expr: &seqExpr{
											pos: position{line: 1512, col: 45, offset: 45093},
											exprs: []any{
												&ruleRefExpr{
													pos:  position{line: 1512, col: 45, offset: 45093},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1512, col: 51, offset: 45099},
													name: "ValueExpr",
												},
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1512, col: 63, offset: 45111},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ValueExpr",
			pos:  position{line: 1537, col: 1, offset: 45901},
			expr: &choiceExpr{
				pos: position{line: 1537, col: 14, offset: 45914},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1537, col: 14, offset: 45914},
						run: (*parser).callonValueExpr2,
						expr: &labeledExpr{
							pos:   position{line: 1537, col: 14, offset: 45914},
							label: "condition",
							expr: &ruleRefExpr{
								pos:  position{line: 1537, col: 24, offset: 45924},
								name: "ConditionExpr",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1546, col: 3, offset: 46114},
						run: (*parser).callonValueExpr5,
						expr: &seqExpr{
							pos: position{line: 1546, col: 3, offset: 46114},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1546, col: 3, offset: 46114},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1546, col: 12, offset: 46123},
									label: "condition",
									expr: &ruleRefExpr{
										pos:  position{line: 1546, col: 22, offset: 46133},
										name: "ConditionExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1546, col: 37, offset: 46148},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1555, col: 3, offset: 46332},
						run: (*parser).callonValueExpr11,
						expr: &labeledExpr{
							pos:   position{line: 1555, col: 3, offset: 46332},
							label: "numeric",
							expr: &ruleRefExpr{
								pos:  position{line: 1555, col: 11, offset: 46340},
								name: "NumericExpr",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1564, col: 3, offset: 46520},
						run: (*parser).callonValueExpr14,
						expr: &labeledExpr{
							pos:   position{line: 1564, col: 3, offset: 46520},
							label: "str",
							expr: &ruleRefExpr{
								pos:  position{line: 1564, col: 7, offset: 46524},
								name: "StringExpr",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1573, col: 3, offset: 46696},
						run: (*parser).callonValueExpr17,
						expr: &seqExpr{
							pos: position{line: 1573, col: 3, offset: 46696},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1573, col: 3, offset: 46696},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1573, col: 12, offset: 46705},
									label: "str",
									expr: &ruleRefExpr{
										pos:  position{line: 1573, col: 16, offset: 46709},
										name: "StringExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1573, col: 28, offset: 46721},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1582, col: 3, offset: 46890},
						run: (*parser).callonValueExpr23,
						expr: &seqExpr{
							pos: position{line: 1582, col: 3, offset: 46890},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1582, col: 3, offset: 46890},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1582, col: 11, offset: 46898},
									label: "boolean",
									expr: &ruleRefExpr{
										pos:  position{line: 1582, col: 19, offset: 46906},
										name: "BoolExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1582, col: 28, offset: 46915},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "StringExpr",
			pos:  position{line: 1592, col: 1, offset: 47086},
			expr: &choiceExpr{
				pos: position{line: 1592, col: 15, offset: 47100},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1592, col: 15, offset: 47100},
						run: (*parser).callonStringExpr2,
						expr: &seqExpr{
							pos: position{line: 1592, col: 15, offset: 47100},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1592, col: 15, offset: 47100},
									label: "text",
									expr: &ruleRefExpr{
										pos:  position{line: 1592, col: 20, offset: 47105},
										name: "TextExpr",
									},
								},
								&notExpr{
									pos: position{line: 1592, col: 29, offset: 47114},
									expr: &ruleRefExpr{
										pos:  position{line: 1592, col: 31, offset: 47116},
										name: "EVAL_CONCAT",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1600, col: 3, offset: 47286},
						run: (*parser).callonStringExpr8,
						expr: &seqExpr{
							pos: position{line: 1600, col: 3, offset: 47286},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1600, col: 3, offset: 47286},
									label: "str",
									expr: &ruleRefExpr{
										pos:  position{line: 1600, col: 7, offset: 47290},
										name: "QuotedString",
									},
								},
								&notExpr{
									pos: position{line: 1600, col: 20, offset: 47303},
									expr: &ruleRefExpr{
										pos:  position{line: 1600, col: 22, offset: 47305},
										name: "EVAL_CONCAT",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1608, col: 3, offset: 47470},
						run: (*parser).callonStringExpr14,
						expr: &seqExpr{
							pos: position{line: 1608, col: 3, offset: 47470},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1608, col: 3, offset: 47470},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 1608, col: 9, offset: 47476},
										name: "EvalFieldToRead",
									},
								},
								&notExpr{
									pos: position{line: 1608, col: 25, offset: 47492},
									expr: &choiceExpr{
										pos: position{line: 1608, col: 27, offset: 47494},
										alternatives: []any{
											&ruleRefExpr{
												pos:  position{line: 1608, col: 27, offset: 47494},
												name: "OpPlus",
											},
											&ruleRefExpr{
												pos:  position{line: 1608, col: 36, offset: 47503},
												name: "OpMinus",
											},
											&ruleRefExpr{
												pos:  position{line: 1608, col: 46, offset: 47513},
												name: "OpMul",
											},
											&ruleRefExpr{
												pos:  position{line: 1608, col: 54, offset: 47521},
												name: "OpDiv",
											},
											&ruleRefExpr{
												pos:  position{line: 1608, col: 62, offset: 47529},
												name: "EVAL_CONCAT",
											},
											&litMatcher{
												pos:        position{line: 1608, col: 76, offset: 47543},
												val:        "(",
												ignoreCase: false,
												want:       "\"(\"",
											},
										},
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1616, col: 3, offset: 47693},
						run: (*parser).callonStringExpr26,
						expr: &labeledExpr{
							pos:   position{line: 1616, col: 3, offset: 47693},
							label: "concat",
							expr: &ruleRefExpr{
								pos:  position{line: 1616, col: 10, offset: 47700},
								name: "ConcatExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "ConcatExpr",
			pos:  position{line: 1626, col: 1, offset: 47906},
			expr: &actionExpr{
				pos: position{line: 1626, col: 15, offset: 47920},
				run: (*parser).callonConcatExpr1,
				expr: &seqExpr{
					pos: position{line: 1626, col: 15, offset: 47920},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1626, col: 15, offset: 47920},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1626, col: 21, offset: 47926},
								name: "ConcatAtom",
							},
						},
						&labeledExpr{
							pos:   position{line: 1626, col: 32, offset: 47937},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1626, col: 37, offset: 47942},
								expr: &seqExpr{
									pos: position{line: 1626, col: 38, offset: 47943},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 1626, col: 38, offset: 47943},
											name: "EVAL_CONCAT",
										},
										&ruleRefExpr{
											pos:  position{line: 1626, col: 50, offset: 47955},
											name: "ConcatAtom",
										},
									},
								},
							},
						},
						&notExpr{
							pos: position{line: 1626, col: 63, offset: 47968},
							expr: &choiceExpr{
								pos: position{line: 1626, col: 65, offset: 47970},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 1626, col: 65, offset: 47970},
										name: "OpPlus",
									},
									&ruleRefExpr{
										pos:  position{line: 1626, col: 74, offset: 47979},
										name: "OpMinus",
									},
									&ruleRefExpr{
										pos:  position{line: 1626, col: 84, offset: 47989},
										name: "OpMul",
									},
									&ruleRefExpr{
										pos:  position{line: 1626, col: 92, offset: 47997},
										name: "OpDiv",
									},
									&litMatcher{
										pos:        position{line: 1626, col: 100, offset: 48005},
										val:        "(",
										ignoreCase: false,
										want:       "\"(\"",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ConcatAtom",
			pos:  position{line: 1644, col: 1, offset: 48411},
			expr: &choiceExpr{
				pos: position{line: 1644, col: 15, offset: 48425},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1644, col: 15, offset: 48425},
						run: (*parser).callonConcatAtom2,
						expr: &labeledExpr{
							pos:   position{line: 1644, col: 15, offset: 48425},
							label: "text",
							expr: &ruleRefExpr{
								pos:  position{line: 1644, col: 20, offset: 48430},
								name: "TextExpr",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1653, col: 3, offset: 48594},
						run: (*parser).callonConcatAtom5,
						expr: &labeledExpr{
							pos:   position{line: 1653, col: 3, offset: 48594},
							label: "str",
							expr: &ruleRefExpr{
								pos:  position{line: 1653, col: 7, offset: 48598},
								name: "QuotedString",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1661, col: 3, offset: 48737},
						run: (*parser).callonConcatAtom8,
						expr: &labeledExpr{
							pos:   position{line: 1661, col: 3, offset: 48737},
							label: "number",
							expr: &ruleRefExpr{
								pos:  position{line: 1661, col: 10, offset: 48744},
								name: "NumberAsString",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1669, col: 3, offset: 48883},
						run: (*parser).callonConcatAtom11,
						expr: &labeledExpr{
							pos:   position{line: 1669, col: 3, offset: 48883},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 1669, col: 9, offset: 48889},
								name: "EvalFieldToRead",
							},
						},
					},
				},
			},
		},
		{
			name: "NumericExpr",
			pos:  position{line: 1679, col: 1, offset: 49058},
			expr: &actionExpr{
				pos: position{line: 1679, col: 16, offset: 49073},
				run: (*parser).callonNumericExpr1,
				expr: &seqExpr{
					pos: position{line: 1679, col: 16, offset: 49073},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1679, col: 16, offset: 49073},
							label: "expr",
							expr: &ruleRefExpr{
								pos:  position{line: 1679, col: 21, offset: 49078},
								name: "NumericExprLevel3",
							},
						},
						&notExpr{
							pos: position{line: 1679, col: 39, offset: 49096},
							expr: &choiceExpr{
								pos: position{line: 1679, col: 41, offset: 49098},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 1679, col: 41, offset: 49098},
										name: "EVAL_CONCAT",
									},
									&litMatcher{
										pos:        position{line: 1679, col: 55, offset: 49112},
										val:        "\"",
										ignoreCase: false,
										want:       "\"\\\"\"",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "NumericExprLevel3",
			pos:  position{line: 1684, col: 1, offset: 49177},
			expr: &actionExpr{
				pos: position{line: 1684, col: 22, offset: 49198},
				run: (*parser).callonNumericExprLevel31,
				expr: &seqExpr{
					pos: position{line: 1684, col: 22, offset: 49198},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1684, col: 22, offset: 49198},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1684, col: 28, offset: 49204},
								name: "NumericExprLevel2",
							},
						},
						&labeledExpr{
							pos:   position{line: 1684, col: 46, offset: 49222},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1684, col: 51, offset: 49227},
								expr: &seqExpr{
									pos: position{line: 1684, col: 52, offset: 49228},
									exprs: []any{
										&choiceExpr{
											pos: position{line: 1684, col: 53, offset: 49229},
											alternatives: []any{
												&ruleRefExpr{
													pos:  position{line: 1684, col: 53, offset: 49229},
													name: "OpPlus",
												},
												&ruleRefExpr{
													pos:  position{line: 1684, col: 62, offset: 49238},
													name: "OpMinus",
												},
											},
										},
										&ruleRefExpr{
											pos:  position{line: 1684, col: 71, offset: 49247},
											name: "NumericExprLevel2",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "NumericExprLevel2",
			pos:  position{line: 1705, col: 1, offset: 49748},
			expr: &actionExpr{
				pos: position{line: 1705, col: 22, offset: 49769},
				run: (*parser).callonNumericExprLevel21,
				expr: &seqExpr{
					pos: position{line: 1705, col: 22, offset: 49769},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1705, col: 22, offset: 49769},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1705, col: 28, offset: 49775},
								name: "NumericExprLevel1",
							},
						},
						&labeledExpr{
							pos:   position{line: 1705, col: 46, offset: 49793},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1705, col: 51, offset: 49798},
								expr: &seqExpr{
									pos: position{line: 1705, col: 52, offset: 49799},
									exprs: []any{
										&choiceExpr{
											pos: position{line: 1705, col: 53, offset: 49800},
											alternatives: []any{
												&ruleRefExpr{
													pos:  position{line: 1705, col: 53, offset: 49800},
													name: "OpMul",
												},
												&ruleRefExpr{
													pos:  position{line: 1705, col: 61, offset: 49808},
													name: "OpDiv",
												},
											},
										},
										&ruleRefExpr{
											pos:  position{line: 1705, col: 68, offset: 49815},
											name: "NumericExprLevel1",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "RoundPrecisionExpr",
			pos:  position{line: 1725, col: 1, offset: 50284},
			expr: &actionExpr{
				pos: position{line: 1725, col: 23, offset: 50306},
				run: (*parser).callonRoundPrecisionExpr1,
				expr: &seqExpr{
					pos: position{line: 1725, col: 23, offset: 50306},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1725, col: 23, offset: 50306},
							name: "COMMA",
						},
						&labeledExpr{
							pos:   position{line: 1725, col: 29, offset: 50312},
							label: "expr",
							expr: &ruleRefExpr{
								pos:  position{line: 1725, col: 34, offset: 50317},
								name: "NumericExprLevel3",
							},
						},
					},
				},
			},
		},
		{
			name: "NumericExprLevel1",
			pos:  position{line: 1735, col: 1, offset: 50561},
			expr: &choiceExpr{
				pos: position{line: 1735, col: 22, offset: 50582},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1735, col: 22, offset: 50582},
						run: (*parser).callonNumericExprLevel12,
						expr: &seqExpr{
							pos: position{line: 1735, col: 22, offset: 50582},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1735, col: 22, offset: 50582},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1735, col: 30, offset: 50590},
									label: "expr",
									expr: &ruleRefExpr{
										pos:  position{line: 1735, col: 35, offset: 50595},
										name: "NumericExprLevel3",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1735, col: 53, offset: 50613},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1738, col: 3, offset: 50648},
						run: (*parser).callonNumericExprLevel18,
						expr: &labeledExpr{
							pos:   position{line: 1738, col: 3, offset: 50648},
							label: "numericEvalExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 1738, col: 20, offset: 50665},
								name: "NumericEvalExpr",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1741, col: 3, offset: 50719},
						run: (*parser).callonNumericExprLevel111,
						expr: &labeledExpr{
							pos:   position{line: 1741, col: 3, offset: 50719},
							label: "field",
							expr: &ruleRefExpr{
								pos:  position{line: 1741, col: 9, offset: 50725},
								name: "EvalFieldToRead",
							},
						},
					},
					&actionExpr{
						pos: position{line: 1751, col: 3, offset: 50944},
						run: (*parser).callonNumericExprLevel114,
						expr: &labeledExpr{
							pos:   position{line: 1751, col: 3, offset: 50944},
							label: "number",
							expr: &ruleRefExpr{
								pos:  position{line: 1751, col: 10, offset: 50951},
								name: "NumberAsString",
							},
						},
					},
				},
			},
		},
		{
			name: "NumericEvalExpr",
			pos:  position{line: 1763, col: 1, offset: 51209},
			expr: &choiceExpr{
				pos: position{line: 1763, col: 20, offset: 51228},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1763, col: 20, offset: 51228},
						run: (*parser).callonNumericEvalExpr2,
						expr: &seqExpr{
							pos: position{line: 1763, col: 21, offset: 51229},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1763, col: 21, offset: 51229},
									label: "opName",
									expr: &choiceExpr{
										pos: position{line: 1763, col: 29, offset: 51237},
										alternatives: []any{
											&litMatcher{
												pos:        position{line: 1763, col: 29, offset: 51237},
												val:        "abs",
												ignoreCase: false,
												want:       "\"abs\"",
											},
											&litMatcher{
												pos:        position{line: 1763, col: 37, offset: 51245},
												val:        "ceil",
												ignoreCase: false,
												want:       "\"ceil\"",
											},
											&litMatcher{
												pos:        position{line: 1763, col: 46, offset: 51254},
												val:        "sqrt",
												ignoreCase: false,
												want:       "\"sqrt\"",
											},
											&litMatcher{
												pos:        position{line: 1763, col: 54, offset: 51262},
												val:        "exact",
												ignoreCase: false,
												want:       "\"exact\"",
											},
											&litMatcher{
												pos:        position{line: 1763, col: 63, offset: 51271},
												val:        "exp",
												ignoreCase: false,
												want:       "\"exp\"",
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1763, col: 70, offset: 51278},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1763, col: 78, offset: 51286},
									label: "expr",
									expr: &ruleRefExpr{
										pos:  position{line: 1763, col: 84, offset: 51292},
										name: "NumericExprLevel3",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1763, col: 103, offset: 51311},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1783, col: 3, offset: 51823},
						run: (*parser).callonNumericEvalExpr15,
						expr: &seqExpr{
							pos: position{line: 1783, col: 3, offset: 51823},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1783, col: 3, offset: 51823},
									label: "roundExpr",
									expr: &litMatcher{
										pos:        position{line: 1783, col: 13, offset: 51833},
										val:        "round",
										ignoreCase: false,
										want:       "\"round\"",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1783, col: 21, offset: 51841},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1783, col: 29, offset: 51849},
									label: "expr",
									expr: &ruleRefExpr{
										pos:  position{line: 1783, col: 35, offset: 51855},
										name: "NumericExprLevel3",
									},
								},
								&labeledExpr{
									pos:   position{line: 1783, col: 54, offset: 51874},
									label: "roundPrecision",
									expr: &zeroOrOneExpr{
										pos: position{line: 1783, col: 69, offset: 51889},
										expr: &ruleRefExpr{
											pos:  position{line: 1783, col: 70, offset: 51890},
											name: "RoundPrecisionExpr",
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1783, col: 91, offset: 51911},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1804, col: 3, offset: 52529},
						run: (*parser).callonNumericEvalExpr26,
						expr: &seqExpr{
							pos: position{line: 1804, col: 3, offset: 52529},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1804, col: 3, offset: 52529},
									val:        "now",
									ignoreCase: false,
									want:       "\"now\"",
								},
								&litMatcher{
									pos:        position{line: 1804, col: 9, offset: 52535},
									val:        "()",
									ignoreCase: false,
									want:       "\"()\"",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1810, col: 3, offset: 52643},
						run: (*parser).callonNumericEvalExpr30,
						expr: &seqExpr{
							pos: position{line: 1810, col: 3, offset: 52643},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 1810, col: 3, offset: 52643},
									val:        "tonumber",
									ignoreCase: false,
									want:       "\"tonumber\"",
								},
								&ruleRefExpr{
									pos:  position{line: 1810, col: 14, offset: 52654},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1810, col: 22, offset: 52662},
									label: "stringExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 1810, col: 33, offset: 52673},
										name: "StringExpr",
									},
								},
								&labeledExpr{
									pos:   position{line: 1810, col: 44, offset: 52684},
									label: "baseExpr",
									expr: &zeroOrOneExpr{
										pos: position{line: 1810, col: 53, offset: 52693},
										expr: &seqExpr{
											pos: position{line: 1810, col: 54, offset: 52694},
											exprs: []any{
												&ruleRefExpr{
													pos:  position{line: 1810, col: 54, offset: 52694},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1810, col: 60, offset: 52700},
													name: "NumericExprLevel3",
												},
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1810, col: 80, offset: 52720},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1838, col: 3, offset: 53562},
						run: (*parser).callonNumericEvalExpr42,
						expr: &seqExpr{
							pos: position{line: 1838, col: 3, offset: 53562},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1838, col: 3, offset: 53562},
									label: "lenExpr",
									expr: &litMatcher{
										pos:        position{line: 1838, col: 12, offset: 53571},
										val:        "len",
										ignoreCase: false,
										want:       "\"len\"",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1838, col: 18, offset: 53577},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1838, col: 26, offset: 53585},
									label: "expr",
									expr: &ruleRefExpr{
										pos:  position{line: 1838, col: 31, offset: 53590},
										name: "LenExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1838, col: 39, offset: 53598},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "LenExpr",
			pos:  position{line: 1842, col: 1, offset: 53632},
			expr: &choiceExpr{
				pos: position{line: 1842, col: 12, offset: 53643},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1842, col: 12, offset: 53643},
						run: (*parser).callonLenExpr2,
						expr: &seqExpr{
							pos: position{line: 1842, col: 12, offset: 53643},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1842, col: 12, offset: 53643},
									label: "str",
									expr: &ruleRefExpr{
										pos:  position{line: 1842, col: 16, offset: 53647},
										name: "QuotedString",
									},
								},
								&notExpr{
									pos: position{line: 1842, col: 29, offset: 53660},
									expr: &ruleRefExpr{
										pos:  position{line: 1842, col: 31, offset: 53662},
										name: "EVAL_CONCAT",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1858, col: 3, offset: 54023},
						run: (*parser).callonLenExpr8,
						expr: &seqExpr{
							pos: position{line: 1858, col: 3, offset: 54023},
							exprs: []any{
								&labeledExpr{
									pos:   position{line: 1858, col: 3, offset: 54023},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 1858, col: 9, offset: 54029},
										name: "EvalFieldToRead",
									},
								},
								&notExpr{
									pos: position{line: 1858, col: 25, offset: 54045},
									expr: &choiceExpr{
										pos: position{line: 1858, col: 27, offset: 54047},
										alternatives: []any{
											&ruleRefExpr{
												pos:  position{line: 1858, col: 27, offset: 54047},
												name: "OpPlus",
											},
											&ruleRefExpr{
												pos:  position{line: 1858, col: 36, offset: 54056},
												name: "OpMinus",
											},
											&ruleRefExpr{
												pos:  position{line: 1858, col: 46, offset: 54066},
												name: "OpMul",
											},
											&ruleRefExpr{
												pos:  position{line: 1858, col: 54, offset: 54074},
												name: "OpDiv",
											},
											&ruleRefExpr{
												pos:  position{line: 1858, col: 62, offset: 54082},
												name: "EVAL_CONCAT",
											},
											&litMatcher{
												pos:        position{line: 1858, col: 76, offset: 54096},
												val:        "(",
												ignoreCase: false,
												want:       "\"(\"",
											},
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "HeadBlock",
			pos:  position{line: 1876, col: 1, offset: 54484},
			expr: &choiceExpr{
				pos: position{line: 1876, col: 14, offset: 54497},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1876, col: 14, offset: 54497},
						run: (*parser).callonHeadBlock2,
						expr: &seqExpr{
							pos: position{line: 1876, col: 14, offset: 54497},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1876, col: 14, offset: 54497},
									name: "PIPE",
								},
								&ruleRefExpr{
									pos:  position{line: 1876, col: 19, offset: 54502},
									name: "CMD_HEAD",
								},
								&zeroOrOneExpr{
									pos: position{line: 1876, col: 28, offset: 54511},
									expr: &seqExpr{
										pos: position{line: 1876, col: 29, offset: 54512},
										exprs: []any{
											&litMatcher{
												pos:        position{line: 1876, col: 29, offset: 54512},
												val:        "limit",
												ignoreCase: false,
												want:       "\"limit\"",
											},
											&ruleRefExpr{
												pos:  position{line: 1876, col: 37, offset: 54520},
												name: "EQUAL",
											},
										},
									},
								},
								&labeledExpr{
									pos:   position{line: 1876, col: 45, offset: 54528},
									label: "intAsStr",
									expr: &ruleRefExpr{
										pos:  position{line: 1876, col: 54, offset: 54537},
										name: "IntegerAsString",
									},
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1891, col: 3, offset: 54953},
						run: (*parser).callonHeadBlock12,
						expr: &seqExpr{
							pos: position{line: 1891, col: 3, offset: 54953},
							exprs: []any{
								&ruleRefExpr{
									pos:  position{line: 1891, col: 3, offset: 54953},
									name: "PIPE",
								},
								&ruleRefExpr{
									pos:  position{line: 1891, col: 8, offset: 54958},
									name: "CMD_HEAD_NO_SPACE",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggregationList",
			pos:  position{line: 1904, col: 1, offset: 55408},
			expr: &actionExpr{
				pos: position{line: 1904, col: 20, offset: 55427},
				run: (*parser).callonAggregationList1,
				expr: &seqExpr{
					pos: position{line: 1904, col: 20, offset: 55427},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1904, col: 20, offset: 55427},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 1904, col: 26, offset: 55433},
								name: "Aggregator",
							},
						},
						&labeledExpr{
							pos:   position{line: 1904, col: 37, offset: 55444},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 1904, col: 42, offset: 55449},
								expr: &seqExpr{
									pos: position{line: 1904, col: 43, offset: 55450},
									exprs: []any{
										&choiceExpr{
											pos: position{line: 1904, col: 44, offset: 55451},
											alternatives: []any{
												&ruleRefExpr{
													pos:  position{line: 1904, col: 44, offset: 55451},
													name: "COMMA",
												},
												&ruleRefExpr{
													pos:  position{line: 1904, col: 52, offset: 55459},
													name: "SPACE",
												},
											},
										},
										&ruleRefExpr{
											pos:  position{line: 1904, col: 59, offset: 55466},
											name: "Aggregator",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "Aggregator",
			pos:  position{line: 1921, col: 1, offset: 55969},
			expr: &actionExpr{
				pos: position{line: 1921, col: 15, offset: 55983},
				run: (*parser).callonAggregator1,
				expr: &seqExpr{
					pos: position{line: 1921, col: 15, offset: 55983},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 1921, col: 15, offset: 55983},
							label: "aggFunc",
							expr: &ruleRefExpr{
								pos:  position{line: 1921, col: 23, offset: 55991},
								name: "AggFunction",
							},
						},
						&labeledExpr{
							pos:   position{line: 1921, col: 35, offset: 56003},
							label: "asField",
							expr: &zeroOrOneExpr{
								pos: position{line: 1921, col: 43, offset: 56011},
								expr: &ruleRefExpr{
									pos:  position{line: 1921, col: 43, offset: 56011},
									name: "AsField",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggFunction",
			pos:  position{line: 1937, col: 1, offset: 56852},
			expr: &actionExpr{
				pos: position{line: 1937, col: 16, offset: 56867},
				run: (*parser).callonAggFunction1,
				expr: &labeledExpr{
					pos:   position{line: 1937, col: 16, offset: 56867},
					label: "agg",
					expr: &choiceExpr{
						pos: position{line: 1937, col: 21, offset: 56872},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 1937, col: 21, offset: 56872},
								name: "AggCount",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 32, offset: 56883},
								name: "AggDistinctCount",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 51, offset: 56902},
								name: "AggAvg",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 60, offset: 56911},
								name: "AggMin",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 69, offset: 56920},
								name: "AggMax",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 78, offset: 56929},
								name: "AggRange",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 89, offset: 56940},
								name: "AggSum",
							},
							&ruleRefExpr{
								pos:  position{line: 1937, col: 98, offset: 56949},
								name: "AggValues",
							},
						},
					},
				},
			},
		},
		{
			name: "AsField",
			pos:  position{line: 1941, col: 1, offset: 56985},
			expr: &actionExpr{
				pos: position{line: 1941, col: 12, offset: 56996},
				run: (*parser).callonAsField1,
				expr: &seqExpr{
					pos: position{line: 1941, col: 12, offset: 56996},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 1941, col: 12, offset: 56996},
							name: "AS",
						},
						&labeledExpr{
							pos:   position{line: 1941, col: 15, offset: 56999},
							label: "field",
							expr: &choiceExpr{
								pos: position{line: 1941, col: 23, offset: 57007},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 1941, col: 23, offset: 57007},
										name: "FieldName",
									},
									&ruleRefExpr{
										pos:  position{line: 1941, col: 35, offset: 57019},
										name: "String",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggCount",
			pos:  position{line: 1955, col: 1, offset: 57348},
			expr: &choiceExpr{
				pos: position{line: 1955, col: 13, offset: 57360},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1955, col: 13, offset: 57360},
						run: (*parser).callonAggCount2,
						expr: &seqExpr{
							pos: position{line: 1955, col: 13, offset: 57360},
							exprs: []any{
								&choiceExpr{
									pos: position{line: 1955, col: 14, offset: 57361},
									alternatives: []any{
										&litMatcher{
											pos:        position{line: 1955, col: 14, offset: 57361},
											val:        "count",
											ignoreCase: false,
											want:       "\"count\"",
										},
										&litMatcher{
											pos:        position{line: 1955, col: 24, offset: 57371},
											val:        "c",
											ignoreCase: false,
											want:       "\"c\"",
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1955, col: 29, offset: 57376},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 1955, col: 37, offset: 57384},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&labeledExpr{
									pos:   position{line: 1955, col: 44, offset: 57391},
									label: "boolExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 1955, col: 53, offset: 57400},
										name: "BoolExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1955, col: 62, offset: 57409},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1970, col: 3, offset: 57759},
						run: (*parser).callonAggCount12,
						expr: &seqExpr{
							pos: position{line: 1970, col: 3, offset: 57759},
							exprs: []any{
								&choiceExpr{
									pos: position{line: 1970, col: 4, offset: 57760},
									alternatives: []any{
										&litMatcher{
											pos:        position{line: 1970, col: 4, offset: 57760},
											val:        "count",
											ignoreCase: false,
											want:       "\"count\"",
										},
										&litMatcher{
											pos:        position{line: 1970, col: 14, offset: 57770},
											val:        "c",
											ignoreCase: false,
											want:       "\"c\"",
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1970, col: 19, offset: 57775},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1970, col: 27, offset: 57783},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 1970, col: 33, offset: 57789},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1970, col: 43, offset: 57799},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1977, col: 5, offset: 57950},
						run: (*parser).callonAggCount21,
						expr: &choiceExpr{
							pos: position{line: 1977, col: 6, offset: 57951},
							alternatives: []any{
								&litMatcher{
									pos:        position{line: 1977, col: 6, offset: 57951},
									val:        "count",
									ignoreCase: false,
									want:       "\"count\"",
								},
								&litMatcher{
									pos:        position{line: 1977, col: 16, offset: 57961},
									val:        "c",
									ignoreCase: false,
									want:       "\"c\"",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggDistinctCount",
			pos:  position{line: 1986, col: 1, offset: 58097},
			expr: &choiceExpr{
				pos: position{line: 1986, col: 21, offset: 58117},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 1986, col: 21, offset: 58117},
						run: (*parser).callonAggDistinctCount2,
						expr: &seqExpr{
							pos: position{line: 1986, col: 21, offset: 58117},
							exprs: []any{
								&choiceExpr{
									pos: position{line: 1986, col: 22, offset: 58118},
									alternatives: []any{
										&litMatcher{
											pos:        position{line: 1986, col: 22, offset: 58118},
											val:        "distinct_count",
											ignoreCase: false,
											want:       "\"distinct_count\"",
										},
										&litMatcher{
											pos:        position{line: 1986, col: 41, offset: 58137},
											val:        "dc",
											ignoreCase: false,
											want:       "\"dc\"",
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1986, col: 47, offset: 58143},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 1986, col: 55, offset: 58151},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&labeledExpr{
									pos:   position{line: 1986, col: 62, offset: 58158},
									label: "valueExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 1986, col: 72, offset: 58168},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1986, col: 82, offset: 58178},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 1996, col: 3, offset: 58412},
						run: (*parser).callonAggDistinctCount12,
						expr: &seqExpr{
							pos: position{line: 1996, col: 3, offset: 58412},
							exprs: []any{
								&choiceExpr{
									pos: position{line: 1996, col: 4, offset: 58413},
									alternatives: []any{
										&litMatcher{
											pos:        position{line: 1996, col: 4, offset: 58413},
											val:        "distinct_count",
											ignoreCase: false,
											want:       "\"distinct_count\"",
										},
										&litMatcher{
											pos:        position{line: 1996, col: 23, offset: 58432},
											val:        "dc",
											ignoreCase: false,
											want:       "\"dc\"",
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1996, col: 29, offset: 58438},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 1996, col: 37, offset: 58446},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 1996, col: 43, offset: 58452},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 1996, col: 53, offset: 58462},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggAvg",
			pos:  position{line: 2005, col: 1, offset: 58618},
			expr: &choiceExpr{
				pos: position{line: 2005, col: 11, offset: 58628},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2005, col: 11, offset: 58628},
						run: (*parser).callonAggAvg2,
						expr: &seqExpr{
							pos: position{line: 2005, col: 11, offset: 58628},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2005, col: 11, offset: 58628},
									val:        "avg",
									ignoreCase: false,
									want:       "\"avg\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2005, col: 17, offset: 58634},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 2005, col: 25, offset: 58642},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2005, col: 32, offset: 58649},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2005, col: 40, offset: 58657},
									label: "boolComparisonExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 2005, col: 59, offset: 58676},
										name: "BoolComparisonExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2005, col: 78, offset: 58695},
									name: "R_PAREN",
								},
								&ruleRefExpr{
									pos:  position{line: 2005, col: 86, offset: 58703},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 2020, col: 3, offset: 59061},
						run: (*parser).callonAggAvg12,
						expr: &seqExpr{
							pos: position{line: 2020, col: 3, offset: 59061},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2020, col: 3, offset: 59061},
									val:        "avg",
									ignoreCase: false,
									want:       "\"avg\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2020, col: 9, offset: 59067},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2020, col: 17, offset: 59075},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 2020, col: 23, offset: 59081},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2020, col: 33, offset: 59091},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggMin",
			pos:  position{line: 2029, col: 1, offset: 59239},
			expr: &choiceExpr{
				pos: position{line: 2029, col: 11, offset: 59249},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2029, col: 11, offset: 59249},
						run: (*parser).callonAggMin2,
						expr: &seqExpr{
							pos: position{line: 2029, col: 11, offset: 59249},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2029, col: 11, offset: 59249},
									val:        "min",
									ignoreCase: false,
									want:       "\"min\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2029, col: 17, offset: 59255},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 2029, col: 25, offset: 59263},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2029, col: 32, offset: 59270},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2029, col: 40, offset: 59278},
									label: "boolComparisonExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 2029, col: 59, offset: 59297},
										name: "BoolComparisonExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2029, col: 78, offset: 59316},
									name: "R_PAREN",
								},
								&ruleRefExpr{
									pos:  position{line: 2029, col: 86, offset: 59324},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 2044, col: 3, offset: 59682},
						run: (*parser).callonAggMin12,
						expr: &seqExpr{
							pos: position{line: 2044, col: 3, offset: 59682},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2044, col: 3, offset: 59682},
									val:        "min",
									ignoreCase: false,
									want:       "\"min\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2044, col: 9, offset: 59688},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2044, col: 17, offset: 59696},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 2044, col: 23, offset: 59702},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2044, col: 33, offset: 59712},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggMax",
			pos:  position{line: 2053, col: 1, offset: 59860},
			expr: &choiceExpr{
				pos: position{line: 2053, col: 11, offset: 59870},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2053, col: 11, offset: 59870},
						run: (*parser).callonAggMax2,
						expr: &seqExpr{
							pos: position{line: 2053, col: 11, offset: 59870},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2053, col: 11, offset: 59870},
									val:        "max",
									ignoreCase: false,
									want:       "\"max\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2053, col: 17, offset: 59876},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 2053, col: 25, offset: 59884},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2053, col: 32, offset: 59891},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2053, col: 41, offset: 59900},
									label: "boolComparisonExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 2053, col: 60, offset: 59919},
										name: "BoolComparisonExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2053, col: 79, offset: 59938},
									name: "R_PAREN",
								},
								&ruleRefExpr{
									pos:  position{line: 2053, col: 87, offset: 59946},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 2068, col: 3, offset: 60304},
						run: (*parser).callonAggMax12,
						expr: &seqExpr{
							pos: position{line: 2068, col: 3, offset: 60304},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2068, col: 3, offset: 60304},
									val:        "max",
									ignoreCase: false,
									want:       "\"max\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2068, col: 9, offset: 60310},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2068, col: 17, offset: 60318},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 2068, col: 23, offset: 60324},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2068, col: 33, offset: 60334},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggRange",
			pos:  position{line: 2077, col: 1, offset: 60482},
			expr: &choiceExpr{
				pos: position{line: 2077, col: 13, offset: 60494},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2077, col: 13, offset: 60494},
						run: (*parser).callonAggRange2,
						expr: &seqExpr{
							pos: position{line: 2077, col: 13, offset: 60494},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2077, col: 13, offset: 60494},
									val:        "range",
									ignoreCase: false,
									want:       "\"range\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2077, col: 21, offset: 60502},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 2077, col: 29, offset: 60510},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2077, col: 36, offset: 60517},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2077, col: 44, offset: 60525},
									label: "boolComparisonExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 2077, col: 63, offset: 60544},
										name: "BoolComparisonExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2077, col: 82, offset: 60563},
									name: "R_PAREN",
								},
								&ruleRefExpr{
									pos:  position{line: 2077, col: 90, offset: 60571},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 2092, col: 3, offset: 60931},
						run: (*parser).callonAggRange12,
						expr: &seqExpr{
							pos: position{line: 2092, col: 3, offset: 60931},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2092, col: 3, offset: 60931},
									val:        "range",
									ignoreCase: false,
									want:       "\"range\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2092, col: 11, offset: 60939},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2092, col: 19, offset: 60947},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 2092, col: 25, offset: 60953},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2092, col: 35, offset: 60963},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggSum",
			pos:  position{line: 2101, col: 1, offset: 61113},
			expr: &choiceExpr{
				pos: position{line: 2101, col: 11, offset: 61123},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2101, col: 11, offset: 61123},
						run: (*parser).callonAggSum2,
						expr: &seqExpr{
							pos: position{line: 2101, col: 11, offset: 61123},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2101, col: 11, offset: 61123},
									val:        "sum",
									ignoreCase: false,
									want:       "\"sum\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2101, col: 17, offset: 61129},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 2101, col: 25, offset: 61137},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2101, col: 32, offset: 61144},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2101, col: 40, offset: 61152},
									label: "boolComparisonExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 2101, col: 59, offset: 61171},
										name: "BoolComparisonExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2101, col: 78, offset: 61190},
									name: "R_PAREN",
								},
								&ruleRefExpr{
									pos:  position{line: 2101, col: 86, offset: 61198},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 2116, col: 3, offset: 61556},
						run: (*parser).callonAggSum12,
						expr: &seqExpr{
							pos: position{line: 2116, col: 3, offset: 61556},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2116, col: 3, offset: 61556},
									val:        "sum",
									ignoreCase: false,
									want:       "\"sum\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2116, col: 9, offset: 61562},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2116, col: 17, offset: 61570},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 2116, col: 23, offset: 61576},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2116, col: 33, offset: 61586},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "AggValues",
			pos:  position{line: 2125, col: 1, offset: 61734},
			expr: &choiceExpr{
				pos: position{line: 2125, col: 14, offset: 61747},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2125, col: 14, offset: 61747},
						run: (*parser).callonAggValues2,
						expr: &seqExpr{
							pos: position{line: 2125, col: 14, offset: 61747},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2125, col: 14, offset: 61747},
									val:        "values",
									ignoreCase: false,
									want:       "\"values\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2125, col: 23, offset: 61756},
									name: "L_PAREN",
								},
								&litMatcher{
									pos:        position{line: 2125, col: 31, offset: 61764},
									val:        "eval",
									ignoreCase: false,
									want:       "\"eval\"",
								},
								&labeledExpr{
									pos:   position{line: 2125, col: 38, offset: 61771},
									label: "valueExpr",
									expr: &ruleRefExpr{
										pos:  position{line: 2125, col: 48, offset: 61781},
										name: "ValueExpr",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2125, col: 58, offset: 61791},
									name: "R_PAREN",
								},
							},
						},
					},
					&actionExpr{
						pos: position{line: 2135, col: 3, offset: 62020},
						run: (*parser).callonAggValues10,
						expr: &seqExpr{
							pos: position{line: 2135, col: 3, offset: 62020},
							exprs: []any{
								&litMatcher{
									pos:        position{line: 2135, col: 3, offset: 62020},
									val:        "values",
									ignoreCase: false,
									want:       "\"values\"",
								},
								&ruleRefExpr{
									pos:  position{line: 2135, col: 12, offset: 62029},
									name: "L_PAREN",
								},
								&labeledExpr{
									pos:   position{line: 2135, col: 20, offset: 62037},
									label: "field",
									expr: &ruleRefExpr{
										pos:  position{line: 2135, col: 26, offset: 62043},
										name: "FieldName",
									},
								},
								&ruleRefExpr{
									pos:  position{line: 2135, col: 36, offset: 62053},
									name: "R_PAREN",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "FieldWithNumberValue",
			pos:  position{line: 2144, col: 1, offset: 62204},
			expr: &actionExpr{
				pos: position{line: 2144, col: 25, offset: 62228},
				run: (*parser).callonFieldWithNumberValue1,
				expr: &labeledExpr{
					pos:   position{line: 2144, col: 25, offset: 62228},
					label: "keyValuePair",
					expr: &choiceExpr{
						pos: position{line: 2144, col: 39, offset: 62242},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 2144, col: 39, offset: 62242},
								name: "NamedFieldWithNumberValue",
							},
							&ruleRefExpr{
								pos:  position{line: 2144, col: 67, offset: 62270},
								name: "UnnamedFieldWithNumberValue",
							},
						},
					},
				},
			},
		},
		{
			name: "NamedFieldWithNumberValue",
			pos:  position{line: 2148, col: 1, offset: 62333},
			expr: &actionExpr{
				pos: position{line: 2148, col: 30, offset: 62362},
				run: (*parser).callonNamedFieldWithNumberValue1,
				expr: &seqExpr{
					pos: position{line: 2148, col: 30, offset: 62362},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2148, col: 30, offset: 62362},
							label: "key",
							expr: &ruleRefExpr{
								pos:  position{line: 2148, col: 34, offset: 62366},
								name: "FieldName",
							},
						},
						&labeledExpr{
							pos:   position{line: 2148, col: 44, offset: 62376},
							label: "op",
							expr: &choiceExpr{
								pos: position{line: 2148, col: 48, offset: 62380},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 2148, col: 48, offset: 62380},
										name: "EqualityOperator",
									},
									&ruleRefExpr{
										pos:  position{line: 2148, col: 67, offset: 62399},
										name: "InequalityOperator",
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 2148, col: 87, offset: 62419},
							label: "value",
							expr: &ruleRefExpr{
								pos:  position{line: 2148, col: 93, offset: 62425},
								name: "Number",
							},
						},
					},
				},
			},
		},
		{
			name: "UnnamedFieldWithNumberValue",
			pos:  position{line: 2161, col: 1, offset: 62659},
			expr: &actionExpr{
				pos: position{line: 2161, col: 32, offset: 62690},
				run: (*parser).callonUnnamedFieldWithNumberValue1,
				expr: &labeledExpr{
					pos:   position{line: 2161, col: 32, offset: 62690},
					label: "value",
					expr: &ruleRefExpr{
						pos:  position{line: 2161, col: 38, offset: 62696},
						name: "Number",
					},
				},
			},
		},
		{
			name: "FieldWithBooleanValue",
			pos:  position{line: 2174, col: 1, offset: 62913},
			expr: &actionExpr{
				pos: position{line: 2174, col: 26, offset: 62938},
				run: (*parser).callonFieldWithBooleanValue1,
				expr: &seqExpr{
					pos: position{line: 2174, col: 26, offset: 62938},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2174, col: 26, offset: 62938},
							label: "key",
							expr: &ruleRefExpr{
								pos:  position{line: 2174, col: 30, offset: 62942},
								name: "FieldName",
							},
						},
						&labeledExpr{
							pos:   position{line: 2174, col: 40, offset: 62952},
							label: "op",
							expr: &ruleRefExpr{
								pos:  position{line: 2174, col: 43, offset: 62955},
								name: "EqualityOperator",
							},
						},
						&labeledExpr{
							pos:   position{line: 2174, col: 60, offset: 62972},
							label: "value",
							expr: &ruleRefExpr{
								pos:  position{line: 2174, col: 66, offset: 62978},
								name: "Boolean",
							},
						},
					},
				},
			},
		},
		{
			name: "FieldWithStringValue",
			pos:  position{line: 2187, col: 1, offset: 63213},
			expr: &actionExpr{
				pos: position{line: 2187, col: 25, offset: 63237},
				run: (*parser).callonFieldWithStringValue1,
				expr: &labeledExpr{
					pos:   position{line: 2187, col: 25, offset: 63237},
					label: "keyValuePair",
					expr: &choiceExpr{
						pos: position{line: 2187, col: 39, offset: 63251},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 2187, col: 39, offset: 63251},
								name: "NamedFieldWithStringValue",
							},
							&ruleRefExpr{
								pos:  position{line: 2187, col: 67, offset: 63279},
								name: "UnnamedFieldWithStringValue",
							},
						},
					},
				},
			},
		},
		{
			name: "NamedFieldWithStringValue",
			pos:  position{line: 2191, col: 1, offset: 63342},
			expr: &actionExpr{
				pos: position{line: 2191, col: 30, offset: 63371},
				run: (*parser).callonNamedFieldWithStringValue1,
				expr: &seqExpr{
					pos: position{line: 2191, col: 30, offset: 63371},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2191, col: 30, offset: 63371},
							label: "key",
							expr: &ruleRefExpr{
								pos:  position{line: 2191, col: 34, offset: 63375},
								name: "FieldName",
							},
						},
						&labeledExpr{
							pos:   position{line: 2191, col: 44, offset: 63385},
							label: "op",
							expr: &ruleRefExpr{
								pos:  position{line: 2191, col: 47, offset: 63388},
								name: "EqualityOperator",
							},
						},
						&labeledExpr{
							pos:   position{line: 2191, col: 64, offset: 63405},
							label: "value",
							expr: &ruleRefExpr{
								pos:  position{line: 2191, col: 70, offset: 63411},
								name: "String",
							},
						},
					},
				},
			},
		},
		{
			name: "UnnamedFieldWithStringValue",
			pos:  position{line: 2203, col: 1, offset: 63644},
			expr: &actionExpr{
				pos: position{line: 2203, col: 32, offset: 63675},
				run: (*parser).callonUnnamedFieldWithStringValue1,
				expr: &labeledExpr{
					pos:   position{line: 2203, col: 32, offset: 63675},
					label: "value",
					expr: &ruleRefExpr{
						pos:  position{line: 2203, col: 38, offset: 63681},
						name: "String",
					},
				},
			},
		},
		{
			name: "FieldNameList",
			pos:  position{line: 2217, col: 1, offset: 64012},
			expr: &actionExpr{
				pos: position{line: 2217, col: 18, offset: 64029},
				run: (*parser).callonFieldNameList1,
				expr: &seqExpr{
					pos: position{line: 2217, col: 18, offset: 64029},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2217, col: 18, offset: 64029},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 2217, col: 24, offset: 64035},
								name: "FieldName",
							},
						},
						&labeledExpr{
							pos:   position{line: 2217, col: 34, offset: 64045},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 2217, col: 39, offset: 64050},
								expr: &seqExpr{
									pos: position{line: 2217, col: 40, offset: 64051},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 2217, col: 40, offset: 64051},
											name: "COMMA",
										},
										&ruleRefExpr{
											pos:  position{line: 2217, col: 46, offset: 64057},
											name: "FieldName",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "FieldName",
			pos:  position{line: 2237, col: 1, offset: 64820},
			expr: &actionExpr{
				pos: position{line: 2237, col: 14, offset: 64833},
				run: (*parser).callonFieldName1,
				expr: &seqExpr{
					pos: position{line: 2237, col: 14, offset: 64833},
					exprs: []any{
						&charClassMatcher{
							pos:        position{line: 2237, col: 14, offset: 64833},
							val:        "[a-zA-Z0-9:*]",
							chars:      []rune{':', '*'},
							ranges:     []rune{'a', 'z', 'A', 'Z', '0', '9'},
							ignoreCase: false,
							inverted:   false,
						},
						&zeroOrMoreExpr{
							pos: position{line: 2237, col: 27, offset: 64846},
							expr: &charClassMatcher{
								pos:        position{line: 2237, col: 27, offset: 64846},
								val:        "[a-zA-Z0-9:_.*]",
								chars:      []rune{':', '_', '.', '*'},
								ranges:     []rune{'a', 'z', 'A', 'Z', '0', '9'},
								ignoreCase: false,
								inverted:   false,
							},
						},
					},
				},
			},
		},
		{
			name: "String",
			pos:  position{line: 2241, col: 1, offset: 64899},
			expr: &actionExpr{
				pos: position{line: 2241, col: 11, offset: 64909},
				run: (*parser).callonString1,
				expr: &labeledExpr{
					pos:   position{line: 2241, col: 11, offset: 64909},
					label: "str",
					expr: &choiceExpr{
						pos: position{line: 2241, col: 16, offset: 64914},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 2241, col: 16, offset: 64914},
								name: "QuotedString",
							},
							&ruleRefExpr{
								pos:  position{line: 2241, col: 31, offset: 64929},
								name: "UnquotedString",
							},
						},
					},
				},
			},
		},
		{
			name: "QuotedString",
			pos:  position{line: 2245, col: 1, offset: 64970},
			expr: &actionExpr{
				pos: position{line: 2245, col: 17, offset: 64986},
				run: (*parser).callonQuotedString1,
				expr: &seqExpr{
					pos: position{line: 2245, col: 17, offset: 64986},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 2245, col: 17, offset: 64986},
							val:        "\"",
							ignoreCase: false,
							want:       "\"\\\"\"",
						},
						&zeroOrMoreExpr{
							pos: position{line: 2245, col: 21, offset: 64990},
							expr: &charClassMatcher{
								pos:        position{line: 2245, col: 21, offset: 64990},
								val:        "[^\"]",
								chars:      []rune{'"'},
								ignoreCase: false,
								inverted:   true,
							},
						},
						&litMatcher{
							pos:        position{line: 2245, col: 27, offset: 64996},
							val:        "\"",
							ignoreCase: false,
							want:       "\"\\\"\"",
						},
					},
				},
			},
		},
		{
			name: "Boolean",
			pos:  position{line: 2250, col: 1, offset: 65107},
			expr: &actionExpr{
				pos: position{line: 2250, col: 12, offset: 65118},
				run: (*parser).callonBoolean1,
				expr: &choiceExpr{
					pos: position{line: 2250, col: 13, offset: 65119},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2250, col: 13, offset: 65119},
							val:        "true",
							ignoreCase: false,
							want:       "\"true\"",
						},
						&litMatcher{
							pos:        position{line: 2250, col: 22, offset: 65128},
							val:        "false",
							ignoreCase: false,
							want:       "\"false\"",
						},
					},
				},
			},
		},
		{
			name: "UnquotedString",
			pos:  position{line: 2255, col: 1, offset: 65222},
			expr: &actionExpr{
				pos: position{line: 2255, col: 19, offset: 65240},
				run: (*parser).callonUnquotedString1,
				expr: &oneOrMoreExpr{
					pos: position{line: 2255, col: 19, offset: 65240},
					expr: &choiceExpr{
						pos: position{line: 2255, col: 20, offset: 65241},
						alternatives: []any{
							&litMatcher{
								pos:        position{line: 2255, col: 20, offset: 65241},
								val:        "*",
								ignoreCase: false,
								want:       "\"*\"",
							},
							&seqExpr{
								pos: position{line: 2255, col: 27, offset: 65248},
								exprs: []any{
									&notExpr{
										pos: position{line: 2255, col: 27, offset: 65248},
										expr: &choiceExpr{
											pos: position{line: 2255, col: 29, offset: 65250},
											alternatives: []any{
												&ruleRefExpr{
													pos:  position{line: 2255, col: 29, offset: 65250},
													name: "MAJOR_BREAK",
												},
												&litMatcher{
													pos:        position{line: 2255, col: 43, offset: 65264},
													val:        "|",
													ignoreCase: false,
													want:       "\"|\"",
												},
												&ruleRefExpr{
													pos:  position{line: 2255, col: 49, offset: 65270},
													name: "EOF",
												},
											},
										},
									},
									&anyMatcher{
										line: 2255, col: 54, offset: 65275,
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "RenamePattern",
			pos:  position{line: 2262, col: 1, offset: 65449},
			expr: &actionExpr{
				pos: position{line: 2262, col: 18, offset: 65466},
				run: (*parser).callonRenamePattern1,
				expr: &oneOrMoreExpr{
					pos: position{line: 2262, col: 18, offset: 65466},
					expr: &charClassMatcher{
						pos:        position{line: 2262, col: 18, offset: 65466},
						val:        "[a-zA-Z0-9_*]",
						chars:      []rune{'_', '*'},
						ranges:     []rune{'a', 'z', 'A', 'Z', '0', '9'},
						ignoreCase: false,
						inverted:   false,
					},
				},
			},
		},
		{
			name: "Number",
			pos:  position{line: 2266, col: 1, offset: 65517},
			expr: &actionExpr{
				pos: position{line: 2266, col: 11, offset: 65527},
				run: (*parser).callonNumber1,
				expr: &labeledExpr{
					pos:   position{line: 2266, col: 11, offset: 65527},
					label: "number",
					expr: &ruleRefExpr{
						pos:  position{line: 2266, col: 18, offset: 65534},
						name: "NumberAsString",
					},
				},
			},
		},
		{
			name: "NumberAsString",
			pos:  position{line: 2272, col: 1, offset: 65723},
			expr: &actionExpr{
				pos: position{line: 2272, col: 19, offset: 65741},
				run: (*parser).callonNumberAsString1,
				expr: &seqExpr{
					pos: position{line: 2272, col: 19, offset: 65741},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2272, col: 19, offset: 65741},
							label: "number",
							expr: &choiceExpr{
								pos: position{line: 2272, col: 27, offset: 65749},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 2272, col: 27, offset: 65749},
										name: "FloatAsString",
									},
									&ruleRefExpr{
										pos:  position{line: 2272, col: 43, offset: 65765},
										name: "IntegerAsString",
									},
								},
							},
						},
						&andExpr{
							pos: position{line: 2272, col: 60, offset: 65782},
							expr: &choiceExpr{
								pos: position{line: 2272, col: 62, offset: 65784},
								alternatives: []any{
									&ruleRefExpr{
										pos:  position{line: 2272, col: 62, offset: 65784},
										name: "SPACE",
									},
									&litMatcher{
										pos:        position{line: 2272, col: 70, offset: 65792},
										val:        "|",
										ignoreCase: false,
										want:       "\"|\"",
									},
									&litMatcher{
										pos:        position{line: 2272, col: 76, offset: 65798},
										val:        ")",
										ignoreCase: false,
										want:       "\")\"",
									},
									&litMatcher{
										pos:        position{line: 2272, col: 82, offset: 65804},
										val:        ",",
										ignoreCase: false,
										want:       "\",\"",
									},
									&ruleRefExpr{
										pos:  position{line: 2272, col: 88, offset: 65810},
										name: "EOF",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "FloatAsString",
			pos:  position{line: 2278, col: 1, offset: 65939},
			expr: &actionExpr{
				pos: position{line: 2278, col: 18, offset: 65956},
				run: (*parser).callonFloatAsString1,
				expr: &seqExpr{
					pos: position{line: 2278, col: 18, offset: 65956},
					exprs: []any{
						&zeroOrOneExpr{
							pos: position{line: 2278, col: 18, offset: 65956},
							expr: &charClassMatcher{
								pos:        position{line: 2278, col: 18, offset: 65956},
								val:        "[-+]",
								chars:      []rune{'-', '+'},
								ignoreCase: false,
								inverted:   false,
							},
						},
						&zeroOrMoreExpr{
							pos: position{line: 2278, col: 24, offset: 65962},
							expr: &charClassMatcher{
								pos:        position{line: 2278, col: 24, offset: 65962},
								val:        "[0-9]",
								ranges:     []rune{'0', '9'},
								ignoreCase: false,
								inverted:   false,
							},
						},
						&litMatcher{
							pos:        position{line: 2278, col: 31, offset: 65969},
							val:        ".",
							ignoreCase: false,
							want:       "\".\"",
						},
						&oneOrMoreExpr{
							pos: position{line: 2278, col: 35, offset: 65973},
							expr: &charClassMatcher{
								pos:        position{line: 2278, col: 35, offset: 65973},
								val:        "[0-9]",
								ranges:     []rune{'0', '9'},
								ignoreCase: false,
								inverted:   false,
							},
						},
					},
				},
			},
		},
		{
			name: "IntegerAsString",
			pos:  position{line: 2283, col: 1, offset: 66068},
			expr: &actionExpr{
				pos: position{line: 2283, col: 20, offset: 66087},
				run: (*parser).callonIntegerAsString1,
				expr: &seqExpr{
					pos: position{line: 2283, col: 20, offset: 66087},
					exprs: []any{
						&zeroOrOneExpr{
							pos: position{line: 2283, col: 20, offset: 66087},
							expr: &charClassMatcher{
								pos:        position{line: 2283, col: 20, offset: 66087},
								val:        "[-+]",
								chars:      []rune{'-', '+'},
								ignoreCase: false,
								inverted:   false,
							},
						},
						&oneOrMoreExpr{
							pos: position{line: 2283, col: 26, offset: 66093},
							expr: &charClassMatcher{
								pos:        position{line: 2283, col: 26, offset: 66093},
								val:        "[0-9]",
								ranges:     []rune{'0', '9'},
								ignoreCase: false,
								inverted:   false,
							},
						},
					},
				},
			},
		},
		{
			name: "EqualityOperator",
			pos:  position{line: 2287, col: 1, offset: 66136},
			expr: &actionExpr{
				pos: position{line: 2287, col: 21, offset: 66156},
				run: (*parser).callonEqualityOperator1,
				expr: &seqExpr{
					pos: position{line: 2287, col: 21, offset: 66156},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2287, col: 21, offset: 66156},
							name: "EMPTY_OR_SPACE",
						},
						&labeledExpr{
							pos:   position{line: 2287, col: 36, offset: 66171},
							label: "op",
							expr: &choiceExpr{
								pos: position{line: 2287, col: 40, offset: 66175},
								alternatives: []any{
									&litMatcher{
										pos:        position{line: 2287, col: 40, offset: 66175},
										val:        "=",
										ignoreCase: false,
										want:       "\"=\"",
									},
									&litMatcher{
										pos:        position{line: 2287, col: 46, offset: 66181},
										val:        "!=",
										ignoreCase: false,
										want:       "\"!=\"",
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 2287, col: 52, offset: 66187},
							name: "EMPTY_OR_SPACE",
						},
					},
				},
			},
		},
		{
			name: "InequalityOperator",
			pos:  position{line: 2295, col: 1, offset: 66368},
			expr: &actionExpr{
				pos: position{line: 2295, col: 23, offset: 66390},
				run: (*parser).callonInequalityOperator1,
				expr: &seqExpr{
					pos: position{line: 2295, col: 23, offset: 66390},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2295, col: 23, offset: 66390},
							name: "EMPTY_OR_SPACE",
						},
						&labeledExpr{
							pos:   position{line: 2295, col: 38, offset: 66405},
							label: "op",
							expr: &choiceExpr{
								pos: position{line: 2295, col: 42, offset: 66409},
								alternatives: []any{
									&litMatcher{
										pos:        position{line: 2295, col: 42, offset: 66409},
										val:        "<=",
										ignoreCase: false,
										want:       "\"<=\"",
									},
									&litMatcher{
										pos:        position{line: 2295, col: 49, offset: 66416},
										val:        "<",
										ignoreCase: false,
										want:       "\"<\"",
									},
									&litMatcher{
										pos:        position{line: 2295, col: 55, offset: 66422},
										val:        ">=",
										ignoreCase: false,
										want:       "\">=\"",
									},
									&litMatcher{
										pos:        position{line: 2295, col: 62, offset: 66429},
										val:        ">",
										ignoreCase: false,
										want:       "\">\"",
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 2295, col: 67, offset: 66434},
							name: "EMPTY_OR_SPACE",
						},
					},
				},
			},
		},
		{
			name: "EqualityOrInequality",
			pos:  position{line: 2303, col: 1, offset: 66617},
			expr: &choiceExpr{
				pos: position{line: 2303, col: 25, offset: 66641},
				alternatives: []any{
					&actionExpr{
						pos: position{line: 2303, col: 25, offset: 66641},
						run: (*parser).callonEqualityOrInequality2,
						expr: &labeledExpr{
							pos:   position{line: 2303, col: 25, offset: 66641},
							label: "op",
							expr: &ruleRefExpr{
								pos:  position{line: 2303, col: 28, offset: 66644},
								name: "EqualityOperator",
							},
						},
					},
					&actionExpr{
						pos: position{line: 2306, col: 3, offset: 66686},
						run: (*parser).callonEqualityOrInequality5,
						expr: &labeledExpr{
							pos:   position{line: 2306, col: 3, offset: 66686},
							label: "op",
							expr: &ruleRefExpr{
								pos:  position{line: 2306, col: 6, offset: 66689},
								name: "InequalityOperator",
							},
						},
					},
				},
			},
		},
		{
			name: "OpPlus",
			pos:  position{line: 2310, col: 1, offset: 66732},
			expr: &actionExpr{
				pos: position{line: 2310, col: 11, offset: 66742},
				run: (*parser).callonOpPlus1,
				expr: &seqExpr{
					pos: position{line: 2310, col: 11, offset: 66742},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2310, col: 11, offset: 66742},
							name: "EMPTY_OR_SPACE",
						},
						&litMatcher{
							pos:        position{line: 2310, col: 26, offset: 66757},
							val:        "+",
							ignoreCase: false,
							want:       "\"+\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2310, col: 30, offset: 66761},
							name: "EMPTY_OR_SPACE",
						},
					},
				},
			},
		},
		{
			name: "OpMinus",
			pos:  position{line: 2314, col: 1, offset: 66801},
			expr: &actionExpr{
				pos: position{line: 2314, col: 12, offset: 66812},
				run: (*parser).callonOpMinus1,
				expr: &seqExpr{
					pos: position{line: 2314, col: 12, offset: 66812},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2314, col: 12, offset: 66812},
							name: "EMPTY_OR_SPACE",
						},
						&litMatcher{
							pos:        position{line: 2314, col: 27, offset: 66827},
							val:        "-",
							ignoreCase: false,
							want:       "\"-\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2314, col: 31, offset: 66831},
							name: "EMPTY_OR_SPACE",
						},
					},
				},
			},
		},
		{
			name: "OpMul",
			pos:  position{line: 2318, col: 1, offset: 66871},
			expr: &actionExpr{
				pos: position{line: 2318, col: 10, offset: 66880},
				run: (*parser).callonOpMul1,
				expr: &seqExpr{
					pos: position{line: 2318, col: 10, offset: 66880},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2318, col: 10, offset: 66880},
							name: "EMPTY_OR_SPACE",
						},
						&litMatcher{
							pos:        position{line: 2318, col: 25, offset: 66895},
							val:        "*",
							ignoreCase: false,
							want:       "\"*\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2318, col: 29, offset: 66899},
							name: "EMPTY_OR_SPACE",
						},
					},
				},
			},
		},
		{
			name: "OpDiv",
			pos:  position{line: 2322, col: 1, offset: 66939},
			expr: &actionExpr{
				pos: position{line: 2322, col: 10, offset: 66948},
				run: (*parser).callonOpDiv1,
				expr: &seqExpr{
					pos: position{line: 2322, col: 10, offset: 66948},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2322, col: 10, offset: 66948},
							name: "EMPTY_OR_SPACE",
						},
						&litMatcher{
							pos:        position{line: 2322, col: 25, offset: 66963},
							val:        "/",
							ignoreCase: false,
							want:       "\"/\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2322, col: 29, offset: 66967},
							name: "EMPTY_OR_SPACE",
						},
					},
				},
			},
		},
		{
			name: "Second",
			pos:  position{line: 2327, col: 1, offset: 67031},
			expr: &actionExpr{
				pos: position{line: 2327, col: 11, offset: 67041},
				run: (*parser).callonSecond1,
				expr: &choiceExpr{
					pos: position{line: 2327, col: 12, offset: 67042},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2327, col: 12, offset: 67042},
							val:        "seconds",
							ignoreCase: false,
							want:       "\"seconds\"",
						},
						&litMatcher{
							pos:        position{line: 2327, col: 24, offset: 67054},
							val:        "second",
							ignoreCase: false,
							want:       "\"second\"",
						},
						&litMatcher{
							pos:        position{line: 2327, col: 35, offset: 67065},
							val:        "secs",
							ignoreCase: false,
							want:       "\"secs\"",
						},
						&litMatcher{
							pos:        position{line: 2327, col: 44, offset: 67074},
							val:        "sec",
							ignoreCase: false,
							want:       "\"sec\"",
						},
						&litMatcher{
							pos:        position{line: 2327, col: 52, offset: 67082},
							val:        "s",
							ignoreCase: false,
							want:       "\"s\"",
						},
					},
				},
			},
		},
		{
			name: "Minute",
			pos:  position{line: 2331, col: 1, offset: 67123},
			expr: &actionExpr{
				pos: position{line: 2331, col: 11, offset: 67133},
				run: (*parser).callonMinute1,
				expr: &choiceExpr{
					pos: position{line: 2331, col: 12, offset: 67134},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2331, col: 12, offset: 67134},
							val:        "minutes",
							ignoreCase: false,
							want:       "\"minutes\"",
						},
						&litMatcher{
							pos:        position{line: 2331, col: 24, offset: 67146},
							val:        "minute",
							ignoreCase: false,
							want:       "\"minute\"",
						},
						&litMatcher{
							pos:        position{line: 2331, col: 35, offset: 67157},
							val:        "mins",
							ignoreCase: false,
							want:       "\"mins\"",
						},
						&litMatcher{
							pos:        position{line: 2331, col: 44, offset: 67166},
							val:        "min",
							ignoreCase: false,
							want:       "\"min\"",
						},
						&litMatcher{
							pos:        position{line: 2331, col: 52, offset: 67174},
							val:        "m",
							ignoreCase: false,
							want:       "\"m\"",
						},
					},
				},
			},
		},
		{
			name: "Hour",
			pos:  position{line: 2335, col: 1, offset: 67215},
			expr: &actionExpr{
				pos: position{line: 2335, col: 9, offset: 67223},
				run: (*parser).callonHour1,
				expr: &choiceExpr{
					pos: position{line: 2335, col: 10, offset: 67224},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2335, col: 10, offset: 67224},
							val:        "hours",
							ignoreCase: false,
							want:       "\"hours\"",
						},
						&litMatcher{
							pos:        position{line: 2335, col: 20, offset: 67234},
							val:        "hour",
							ignoreCase: false,
							want:       "\"hour\"",
						},
						&litMatcher{
							pos:        position{line: 2335, col: 29, offset: 67243},
							val:        "hrs",
							ignoreCase: false,
							want:       "\"hrs\"",
						},
						&litMatcher{
							pos:        position{line: 2335, col: 37, offset: 67251},
							val:        "hr",
							ignoreCase: false,
							want:       "\"hr\"",
						},
						&litMatcher{
							pos:        position{line: 2335, col: 44, offset: 67258},
							val:        "h",
							ignoreCase: false,
							want:       "\"h\"",
						},
					},
				},
			},
		},
		{
			name: "Day",
			pos:  position{line: 2339, col: 1, offset: 67297},
			expr: &actionExpr{
				pos: position{line: 2339, col: 8, offset: 67304},
				run: (*parser).callonDay1,
				expr: &choiceExpr{
					pos: position{line: 2339, col: 9, offset: 67305},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2339, col: 9, offset: 67305},
							val:        "days",
							ignoreCase: false,
							want:       "\"days\"",
						},
						&litMatcher{
							pos:        position{line: 2339, col: 18, offset: 67314},
							val:        "day",
							ignoreCase: false,
							want:       "\"day\"",
						},
						&litMatcher{
							pos:        position{line: 2339, col: 26, offset: 67322},
							val:        "d",
							ignoreCase: false,
							want:       "\"d\"",
						},
					},
				},
			},
		},
		{
			name: "Week",
			pos:  position{line: 2343, col: 1, offset: 67360},
			expr: &actionExpr{
				pos: position{line: 2343, col: 9, offset: 67368},
				run: (*parser).callonWeek1,
				expr: &choiceExpr{
					pos: position{line: 2343, col: 10, offset: 67369},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2343, col: 10, offset: 67369},
							val:        "weeks",
							ignoreCase: false,
							want:       "\"weeks\"",
						},
						&litMatcher{
							pos:        position{line: 2343, col: 20, offset: 67379},
							val:        "week",
							ignoreCase: false,
							want:       "\"week\"",
						},
						&litMatcher{
							pos:        position{line: 2343, col: 29, offset: 67388},
							val:        "w",
							ignoreCase: false,
							want:       "\"w\"",
						},
					},
				},
			},
		},
		{
			name: "Month",
			pos:  position{line: 2347, col: 1, offset: 67427},
			expr: &actionExpr{
				pos: position{line: 2347, col: 10, offset: 67436},
				run: (*parser).callonMonth1,
				expr: &choiceExpr{
					pos: position{line: 2347, col: 11, offset: 67437},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2347, col: 11, offset: 67437},
							val:        "months",
							ignoreCase: false,
							want:       "\"months\"",
						},
						&litMatcher{
							pos:        position{line: 2347, col: 22, offset: 67448},
							val:        "month",
							ignoreCase: false,
							want:       "\"month\"",
						},
						&litMatcher{
							pos:        position{line: 2347, col: 32, offset: 67458},
							val:        "mon",
							ignoreCase: false,
							want:       "\"mon\"",
						},
					},
				},
			},
		},
		{
			name: "Quarter",
			pos:  position{line: 2351, col: 1, offset: 67500},
			expr: &actionExpr{
				pos: position{line: 2351, col: 12, offset: 67511},
				run: (*parser).callonQuarter1,
				expr: &choiceExpr{
					pos: position{line: 2351, col: 13, offset: 67512},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2351, col: 13, offset: 67512},
							val:        "quarters",
							ignoreCase: false,
							want:       "\"quarters\"",
						},
						&litMatcher{
							pos:        position{line: 2351, col: 26, offset: 67525},
							val:        "quarter",
							ignoreCase: false,
							want:       "\"quarter\"",
						},
						&litMatcher{
							pos:        position{line: 2351, col: 38, offset: 67537},
							val:        "qtrs",
							ignoreCase: false,
							want:       "\"qtrs\"",
						},
						&litMatcher{
							pos:        position{line: 2351, col: 47, offset: 67546},
							val:        "qtr",
							ignoreCase: false,
							want:       "\"qtr\"",
						},
						&litMatcher{
							pos:        position{line: 2351, col: 55, offset: 67554},
							val:        "q",
							ignoreCase: false,
							want:       "\"q\"",
						},
					},
				},
			},
		},
		{
			name: "Subseconds",
			pos:  position{line: 2356, col: 1, offset: 67688},
			expr: &actionExpr{
				pos: position{line: 2356, col: 15, offset: 67702},
				run: (*parser).callonSubseconds1,
				expr: &choiceExpr{
					pos: position{line: 2356, col: 16, offset: 67703},
					alternatives: []any{
						&litMatcher{
							pos:        position{line: 2356, col: 16, offset: 67703},
							val:        "us",
							ignoreCase: false,
							want:       "\"us\"",
						},
						&litMatcher{
							pos:        position{line: 2356, col: 23, offset: 67710},
							val:        "ms",
							ignoreCase: false,
							want:       "\"ms\"",
						},
						&litMatcher{
							pos:        position{line: 2356, col: 30, offset: 67717},
							val:        "cs",
							ignoreCase: false,
							want:       "\"cs\"",
						},
						&litMatcher{
							pos:        position{line: 2356, col: 37, offset: 67724},
							val:        "ds",
							ignoreCase: false,
							want:       "\"ds\"",
						},
					},
				},
			},
		},
		{
			name: "TransactionBlock",
			pos:  position{line: 2365, col: 1, offset: 67947},
			expr: &actionExpr{
				pos: position{line: 2365, col: 21, offset: 67967},
				run: (*parser).callonTransactionBlock1,
				expr: &seqExpr{
					pos: position{line: 2365, col: 21, offset: 67967},
					exprs: []any{
						&ruleRefExpr{
							pos:  position{line: 2365, col: 21, offset: 67967},
							name: "PIPE",
						},
						&ruleRefExpr{
							pos:  position{line: 2365, col: 26, offset: 67972},
							name: "CMD_TRANSACTION",
						},
						&labeledExpr{
							pos:   position{line: 2365, col: 42, offset: 67988},
							label: "txnOptions",
							expr: &ruleRefExpr{
								pos:  position{line: 2365, col: 53, offset: 67999},
								name: "TransactionOptions",
							},
						},
					},
				},
			},
		},
		{
			name: "TransactionOptions",
			pos:  position{line: 2374, col: 1, offset: 68305},
			expr: &actionExpr{
				pos: position{line: 2374, col: 23, offset: 68327},
				run: (*parser).callonTransactionOptions1,
				expr: &labeledExpr{
					pos:   position{line: 2374, col: 23, offset: 68327},
					label: "txnOptions",
					expr: &zeroOrOneExpr{
						pos: position{line: 2374, col: 34, offset: 68338},
						expr: &ruleRefExpr{
							pos:  position{line: 2374, col: 34, offset: 68338},
							name: "TransactionDefinitionOptionsList",
						},
					},
				},
			},
		},
		{
			name: "TransactionDefinitionOptionsList",
			pos:  position{line: 2389, col: 1, offset: 68729},
			expr: &actionExpr{
				pos: position{line: 2389, col: 37, offset: 68765},
				run: (*parser).callonTransactionDefinitionOptionsList1,
				expr: &seqExpr{
					pos: position{line: 2389, col: 37, offset: 68765},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2389, col: 37, offset: 68765},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 2389, col: 43, offset: 68771},
								name: "TransactionDefinitionOption",
							},
						},
						&labeledExpr{
							pos:   position{line: 2389, col: 71, offset: 68799},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 2389, col: 76, offset: 68804},
								expr: &seqExpr{
									pos: position{line: 2389, col: 77, offset: 68805},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 2389, col: 77, offset: 68805},
											name: "SPACE",
										},
										&ruleRefExpr{
											pos:  position{line: 2389, col: 83, offset: 68811},
											name: "TransactionDefinitionOption",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "TransactionDefinitionOption",
			pos:  position{line: 2424, col: 1, offset: 69800},
			expr: &actionExpr{
				pos: position{line: 2424, col: 32, offset: 69831},
				run: (*parser).callonTransactionDefinitionOption1,
				expr: &labeledExpr{
					pos:   position{line: 2424, col: 32, offset: 69831},
					label: "option",
					expr: &choiceExpr{
						pos: position{line: 2424, col: 40, offset: 69839},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 2424, col: 40, offset: 69839},
								name: "SpaceSeparatedFieldNameList",
							},
							&ruleRefExpr{
								pos:  position{line: 2424, col: 70, offset: 69869},
								name: "StartsWithOption",
							},
							&ruleRefExpr{
								pos:  position{line: 2424, col: 89, offset: 69888},
								name: "EndsWithOption",
							},
						},
					},
				},
			},
		},
		{
			name: "SpaceSeparatedFieldNameList",
			pos:  position{line: 2430, col: 1, offset: 70034},
			expr: &actionExpr{
				pos: position{line: 2430, col: 32, offset: 70065},
				run: (*parser).callonSpaceSeparatedFieldNameList1,
				expr: &seqExpr{
					pos: position{line: 2430, col: 32, offset: 70065},
					exprs: []any{
						&labeledExpr{
							pos:   position{line: 2430, col: 32, offset: 70065},
							label: "first",
							expr: &ruleRefExpr{
								pos:  position{line: 2430, col: 38, offset: 70071},
								name: "FieldName",
							},
						},
						&notExpr{
							pos: position{line: 2430, col: 48, offset: 70081},
							expr: &ruleRefExpr{
								pos:  position{line: 2430, col: 50, offset: 70083},
								name: "EQUAL",
							},
						},
						&labeledExpr{
							pos:   position{line: 2430, col: 57, offset: 70090},
							label: "rest",
							expr: &zeroOrMoreExpr{
								pos: position{line: 2430, col: 62, offset: 70095},
								expr: &seqExpr{
									pos: position{line: 2430, col: 63, offset: 70096},
									exprs: []any{
										&ruleRefExpr{
											pos:  position{line: 2430, col: 63, offset: 70096},
											name: "SPACE",
										},
										&ruleRefExpr{
											pos:  position{line: 2430, col: 69, offset: 70102},
											name: "FieldName",
										},
										&notExpr{
											pos: position{line: 2430, col: 79, offset: 70112},
											expr: &ruleRefExpr{
												pos:  position{line: 2430, col: 81, offset: 70114},
												name: "EQUAL",
											},
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "StartsWithOption",
			pos:  position{line: 2448, col: 1, offset: 70538},
			expr: &actionExpr{
				pos: position{line: 2448, col: 21, offset: 70558},
				run: (*parser).callonStartsWithOption1,
				expr: &seqExpr{
					pos: position{line: 2448, col: 21, offset: 70558},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 2448, col: 21, offset: 70558},
							val:        "startswith",
							ignoreCase: false,
							want:       "\"startswith\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2448, col: 34, offset: 70571},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 2448, col: 40, offset: 70577},
							label: "strExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 2448, col: 48, offset: 70585},
								name: "TransactionFilterString",
							},
						},
					},
				},
			},
		},
		{
			name: "EndsWithOption",
			pos:  position{line: 2458, col: 1, offset: 70823},
			expr: &actionExpr{
				pos: position{line: 2458, col: 19, offset: 70841},
				run: (*parser).callonEndsWithOption1,
				expr: &seqExpr{
					pos: position{line: 2458, col: 19, offset: 70841},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 2458, col: 19, offset: 70841},
							val:        "endswith",
							ignoreCase: false,
							want:       "\"endswith\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2458, col: 30, offset: 70852},
							name: "EQUAL",
						},
						&labeledExpr{
							pos:   position{line: 2458, col: 36, offset: 70858},
							label: "strExpr",
							expr: &ruleRefExpr{
								pos:  position{line: 2458, col: 44, offset: 70866},
								name: "TransactionFilterString",
							},
						},
					},
				},
			},
		},
		{
			name: "TransactionFilterString",
			pos:  position{line: 2469, col: 1, offset: 71135},
			expr: &actionExpr{
				pos: position{line: 2469, col: 28, offset: 71162},
				run: (*parser).callonTransactionFilterString1,
				expr: &labeledExpr{
					pos:   position{line: 2469, col: 28, offset: 71162},
					label: "strExpr",
					expr: &choiceExpr{
						pos: position{line: 2469, col: 37, offset: 71171},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 2469, col: 37, offset: 71171},
								name: "TransactionQuotedString",
							},
							&ruleRefExpr{
								pos:  position{line: 2469, col: 63, offset: 71197},
								name: "TransactionEval",
							},
							&ruleRefExpr{
								pos:  position{line: 2469, col: 81, offset: 71215},
								name: "TransactionSearch",
							},
						},
					},
				},
			},
		},
		{
			name: "TransactionQuotedString",
			pos:  position{line: 2473, col: 1, offset: 71263},
			expr: &actionExpr{
				pos: position{line: 2473, col: 28, offset: 71290},
				run: (*parser).callonTransactionQuotedString1,
				expr: &labeledExpr{
					pos:   position{line: 2473, col: 28, offset: 71290},
					label: "str",
					expr: &choiceExpr{
						pos: position{line: 2473, col: 33, offset: 71295},
						alternatives: []any{
							&ruleRefExpr{
								pos:  position{line: 2473, col: 33, offset: 71295},
								name: "TransactionQuotedStringValue",
							},
							&ruleRefExpr{
								pos:  position{line: 2473, col: 64, offset: 71326},
								name: "TransactionQuotedStringSearchExpr",
							},
						},
					},
				},
			},
		},
		{
			name: "TransactionQuotedStringSearchExpr",
			pos:  position{line: 2477, col: 1, offset: 71386},
			expr: &actionExpr{
				pos: position{line: 2477, col: 38, offset: 71423},
				run: (*parser).callonTransactionQuotedStringSearchExpr1,
				expr: &seqExpr{
					pos: position{line: 2477, col: 38, offset: 71423},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 2477, col: 38, offset: 71423},
							val:        "\"",
							ignoreCase: false,
							want:       "\"\\\"\"",
						},
						&labeledExpr{
							pos:   position{line: 2477, col: 42, offset: 71427},
							label: "searchClause",
							expr: &ruleRefExpr{
								pos:  position{line: 2477, col: 55, offset: 71440},
								name: "ClauseLevel4",
							},
						},
						&litMatcher{
							pos:        position{line: 2477, col: 68, offset: 71453},
							val:        "\"",
							ignoreCase: false,
							want:       "\"\\\"\"",
						},
					},
				},
			},
		},
		{
			name: "QuotedStringNoOp",
			pos:  position{line: 2485, col: 1, offset: 71592},
			expr: &actionExpr{
				pos: position{line: 2485, col: 21, offset: 71612},
				run: (*parser).callonQuotedStringNoOp1,
				expr: &seqExpr{
					pos: position{line: 2485, col: 21, offset: 71612},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 2485, col: 21, offset: 71612},
							val:        "\"",
							ignoreCase: false,
							want:       "\"\\\"\"",
						},
						&zeroOrMoreExpr{
							pos: position{line: 2485, col: 25, offset: 71616},
							expr: &charClassMatcher{
								pos:        position{line: 2485, col: 25, offset: 71616},
								val:        "[^\" !(OR / AND)]",
								chars:      []rune{'"', ' ', '!', '(', 'O', 'R', ' ', '/', ' ', 'A', 'N', 'D', ')'},
								ignoreCase: false,
								inverted:   true,
							},
						},
						&litMatcher{
							pos:        position{line: 2485, col: 44, offset: 71635},
							val:        "\"",
							ignoreCase: false,
							want:       "\"\\\"\"",
						},
					},
				},
			},
		},
		{
			name: "TransactionQuotedStringValue",
			pos:  position{line: 2490, col: 1, offset: 71746},
			expr: &actionExpr{
				pos: position{line: 2490, col: 33, offset: 71778},
				run: (*parser).callonTransactionQuotedStringValue1,
				expr: &labeledExpr{
					pos:   position{line: 2490, col: 33, offset: 71778},
					label: "str",
					expr: &ruleRefExpr{
						pos:  position{line: 2490, col: 37, offset: 71782},
						name: "QuotedStringNoOp",
					},
				},
			},
		},
		{
			name: "TransactionSearch",
			pos:  position{line: 2498, col: 1, offset: 71937},
			expr: &actionExpr{
				pos: position{line: 2498, col: 22, offset: 71958},
				run: (*parser).callonTransactionSearch1,
				expr: &labeledExpr{
					pos:   position{line: 2498, col: 22, offset: 71958},
					label: "expr",
					expr: &ruleRefExpr{
						pos:  position{line: 2498, col: 27, offset: 71963},
						name: "ClauseLevel1",
					},
				},
			},
		},
		{
			name: "TransactionEval",
			pos:  position{line: 2508, col: 1, offset: 72135},
			expr: &actionExpr{
				pos: position{line: 2508, col: 20, offset: 72154},
				run: (*parser).callonTransactionEval1,
				expr: &seqExpr{
					pos: position{line: 2508, col: 20, offset: 72154},
					exprs: []any{
						&litMatcher{
							pos:        position{line: 2508, col: 20, offset: 72154},
							val:        "eval",
							ignoreCase: false,
							want:       "\"eval\"",
						},
						&ruleRefExpr{
							pos:  position{line: 2508, col: 27, offset: 72161},
							name: "EMPTY_OR_SPACE",
						},
						&ruleRefExpr{
							pos:  position{line: 2508, col: 42, offset: 72176},
							name: "L_PAREN",
						},
						&labeledExpr{
							pos:   position{line: 2508, col: 50, offset: 72184},
							label: "condition",
							expr: &ruleRefExpr{
								pos:  position{line: 2508, col: 60, offset: 72194},
								name: "BoolExpr",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 2508, col: 69, offset: 72203},
							name: "R_PAREN",
						},
					},
				},
			},
		},
		{
			name: "ALLCMD",
			pos:  position{line: 2518, col: 1, offset: 72384},
			expr: &choiceExpr{
				pos: position{line: 2518, col: 12, offset: 72395},
				alternatives: []any{
					&ruleRefExpr{
						pos:  position{line: 2518, col: 12, offset: 72395},
						name: "CMD_REGEX",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 24, offset: 72407},
						name: "CMD_STATS",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 36, offset: 72419},
						name: "CMD_FIELDS",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 49, offset: 72432},
						name: "CMD_WHERE",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 61, offset: 72444},
						name: "CMD_HEAD_NO_SPACE",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 81, offset: 72464},
						name: "CMD_HEAD",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 92, offset: 72475},
						name: "CMD_EVAL",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 103, offset: 72486},
						name: "CMD_REX",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 113, offset: 72496},
						name: "CMD_TOP",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 123, offset: 72506},
						name: "CMD_RARE",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 134, offset: 72517},
						name: "CMD_RENAME",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 147, offset: 72530},
						name: "CMD_TIMECHART",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 163, offset: 72546},
						name: "CMD_TRANSACTION",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 181, offset: 72564},
						name: "CMD_DEDUP",
					},
					&ruleRefExpr{
						pos:  position{line: 2518, col: 193, offset: 72576},
						name: "CMD_SORT",
					},
				},
			},
		},
		{
			name: "CMD_SEARCH",
			pos:  position{line: 2519, col: 1, offset: 72586},
			expr: &seqExpr{
				pos: position{line: 2519, col: 15, offset: 72600},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2519, col: 15, offset: 72600},
						val:        "search",
						ignoreCase: false,
						want:       "\"search\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2519, col: 24, offset: 72609},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_REGEX",
			pos:  position{line: 2520, col: 1, offset: 72615},
			expr: &seqExpr{
				pos: position{line: 2520, col: 14, offset: 72628},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2520, col: 14, offset: 72628},
						val:        "regex",
						ignoreCase: false,
						want:       "\"regex\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2520, col: 22, offset: 72636},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_STATS",
			pos:  position{line: 2521, col: 1, offset: 72642},
			expr: &seqExpr{
				pos: position{line: 2521, col: 14, offset: 72655},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2521, col: 14, offset: 72655},
						val:        "stats",
						ignoreCase: false,
						want:       "\"stats\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2521, col: 22, offset: 72663},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_FIELDS",
			pos:  position{line: 2522, col: 1, offset: 72669},
			expr: &seqExpr{
				pos: position{line: 2522, col: 15, offset: 72683},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2522, col: 15, offset: 72683},
						val:        "fields",
						ignoreCase: false,
						want:       "\"fields\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2522, col: 24, offset: 72692},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_WHERE",
			pos:  position{line: 2523, col: 1, offset: 72698},
			expr: &seqExpr{
				pos: position{line: 2523, col: 14, offset: 72711},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2523, col: 14, offset: 72711},
						val:        "where",
						ignoreCase: false,
						want:       "\"where\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2523, col: 22, offset: 72719},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_HEAD_NO_SPACE",
			pos:  position{line: 2524, col: 1, offset: 72725},
			expr: &litMatcher{
				pos:        position{line: 2524, col: 22, offset: 72746},
				val:        "head",
				ignoreCase: false,
				want:       "\"head\"",
			},
		},
		{
			name: "CMD_HEAD",
			pos:  position{line: 2525, col: 1, offset: 72753},
			expr: &seqExpr{
				pos: position{line: 2525, col: 13, offset: 72765},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2525, col: 13, offset: 72765},
						name: "CMD_HEAD_NO_SPACE",
					},
					&ruleRefExpr{
						pos:  position{line: 2525, col: 31, offset: 72783},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_EVAL",
			pos:  position{line: 2526, col: 1, offset: 72789},
			expr: &seqExpr{
				pos: position{line: 2526, col: 13, offset: 72801},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2526, col: 13, offset: 72801},
						val:        "eval",
						ignoreCase: false,
						want:       "\"eval\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2526, col: 20, offset: 72808},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_REX",
			pos:  position{line: 2527, col: 1, offset: 72814},
			expr: &seqExpr{
				pos: position{line: 2527, col: 12, offset: 72825},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2527, col: 12, offset: 72825},
						val:        "rex",
						ignoreCase: false,
						want:       "\"rex\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2527, col: 18, offset: 72831},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_SORT",
			pos:  position{line: 2528, col: 1, offset: 72837},
			expr: &seqExpr{
				pos: position{line: 2528, col: 13, offset: 72849},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2528, col: 13, offset: 72849},
						val:        "sort",
						ignoreCase: false,
						want:       "\"sort\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2528, col: 20, offset: 72856},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_TOP",
			pos:  position{line: 2529, col: 1, offset: 72862},
			expr: &litMatcher{
				pos:        position{line: 2529, col: 12, offset: 72873},
				val:        "top",
				ignoreCase: false,
				want:       "\"top\"",
			},
		},
		{
			name: "CMD_RARE",
			pos:  position{line: 2530, col: 1, offset: 72879},
			expr: &litMatcher{
				pos:        position{line: 2530, col: 13, offset: 72891},
				val:        "rare",
				ignoreCase: false,
				want:       "\"rare\"",
			},
		},
		{
			name: "CMD_RENAME",
			pos:  position{line: 2531, col: 1, offset: 72898},
			expr: &seqExpr{
				pos: position{line: 2531, col: 15, offset: 72912},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2531, col: 15, offset: 72912},
						val:        "rename",
						ignoreCase: false,
						want:       "\"rename\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2531, col: 24, offset: 72921},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_TIMECHART",
			pos:  position{line: 2532, col: 1, offset: 72927},
			expr: &seqExpr{
				pos: position{line: 2532, col: 18, offset: 72944},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2532, col: 18, offset: 72944},
						val:        "timechart",
						ignoreCase: false,
						want:       "\"timechart\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2532, col: 30, offset: 72956},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_SPAN",
			pos:  position{line: 2533, col: 1, offset: 72962},
			expr: &litMatcher{
				pos:        position{line: 2533, col: 13, offset: 72974},
				val:        "span",
				ignoreCase: false,
				want:       "\"span\"",
			},
		},
		{
			name: "CMD_TRANSACTION",
			pos:  position{line: 2534, col: 1, offset: 72981},
			expr: &seqExpr{
				pos: position{line: 2534, col: 20, offset: 73000},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2534, col: 20, offset: 73000},
						val:        "transaction",
						ignoreCase: false,
						want:       "\"transaction\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2534, col: 34, offset: 73014},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "CMD_DEDUP",
			pos:  position{line: 2535, col: 1, offset: 73020},
			expr: &litMatcher{
				pos:        position{line: 2535, col: 14, offset: 73033},
				val:        "dedup",
				ignoreCase: false,
				want:       "\"dedup\"",
			},
		},
		{
			name: "CMD_DEDUP_SORTBY",
			pos:  position{line: 2536, col: 1, offset: 73041},
			expr: &seqExpr{
				pos: position{line: 2536, col: 21, offset: 73061},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2536, col: 21, offset: 73061},
						name: "SPACE",
					},
					&litMatcher{
						pos:        position{line: 2536, col: 27, offset: 73067},
						val:        "sortby",
						ignoreCase: false,
						want:       "\"sortby\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2536, col: 36, offset: 73076},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "EVAL_CONCAT",
			pos:  position{line: 2537, col: 1, offset: 73082},
			expr: &seqExpr{
				pos: position{line: 2537, col: 16, offset: 73097},
				exprs: []any{
					&zeroOrOneExpr{
						pos: position{line: 2537, col: 16, offset: 73097},
						expr: &ruleRefExpr{
							pos:  position{line: 2537, col: 16, offset: 73097},
							name: "SPACE",
						},
					},
					&litMatcher{
						pos:        position{line: 2537, col: 23, offset: 73104},
						val:        ".",
						ignoreCase: false,
						want:       "\".\"",
					},
					&zeroOrOneExpr{
						pos: position{line: 2537, col: 27, offset: 73108},
						expr: &ruleRefExpr{
							pos:  position{line: 2537, col: 27, offset: 73108},
							name: "SPACE",
						},
					},
				},
			},
		},
		{
			name: "MAJOR_BREAK",
			pos:  position{line: 2540, col: 1, offset: 73219},
			expr: &choiceExpr{
				pos: position{line: 2540, col: 16, offset: 73234},
				alternatives: []any{
					&charClassMatcher{
						pos:        position{line: 2540, col: 16, offset: 73234},
						val:        "[[\\]<>(){}|!;,'\"*\\n\\r \\t&?+]",
						chars:      []rune{'[', ']', '<', '>', '(', ')', '{', '}', '|', '!', ';', ',', '\'', '"', '*', '\n', '\r', ' ', '\t', '&', '?', '+'},
						ignoreCase: false,
						inverted:   false,
					},
					&litMatcher{
						pos:        position{line: 2540, col: 47, offset: 73265},
						val:        "%21",
						ignoreCase: false,
						want:       "\"%21\"",
					},
					&litMatcher{
						pos:        position{line: 2540, col: 55, offset: 73273},
						val:        "%26",
						ignoreCase: false,
						want:       "\"%26\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 16, offset: 73296},
						val:        "%2526",
						ignoreCase: false,
						want:       "\"%2526\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 26, offset: 73306},
						val:        "%3B",
						ignoreCase: false,
						want:       "\"%3B\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 34, offset: 73314},
						val:        "%7C",
						ignoreCase: false,
						want:       "\"%7C\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 42, offset: 73322},
						val:        "%20",
						ignoreCase: false,
						want:       "\"%20\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 50, offset: 73330},
						val:        "%2B",
						ignoreCase: false,
						want:       "\"%2B\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 58, offset: 73338},
						val:        "%3D",
						ignoreCase: false,
						want:       "\"%3D\"",
					},
					&litMatcher{
						pos:        position{line: 2541, col: 66, offset: 73346},
						val:        "--",
						ignoreCase: false,
						want:       "\"--\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 16, offset: 73368},
						val:        "%2520",
						ignoreCase: false,
						want:       "\"%2520\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 26, offset: 73378},
						val:        "%5D",
						ignoreCase: false,
						want:       "\"%5D\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 34, offset: 73386},
						val:        "%5B",
						ignoreCase: false,
						want:       "\"%5B\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 42, offset: 73394},
						val:        "%3A",
						ignoreCase: false,
						want:       "\"%3A\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 50, offset: 73402},
						val:        "%0A",
						ignoreCase: false,
						want:       "\"%0A\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 58, offset: 73410},
						val:        "%2C",
						ignoreCase: false,
						want:       "\"%2C\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 66, offset: 73418},
						val:        "%28",
						ignoreCase: false,
						want:       "\"%28\"",
					},
					&litMatcher{
						pos:        position{line: 2542, col: 74, offset: 73426},
						val:        "%29",
						ignoreCase: false,
						want:       "\"%29\"",
					},
				},
			},
		},
		{
			name: "MINOR_BREAK",
			pos:  position{line: 2543, col: 1, offset: 73432},
			expr: &choiceExpr{
				pos: position{line: 2543, col: 16, offset: 73447},
				alternatives: []any{
					&charClassMatcher{
						pos:        position{line: 2543, col: 16, offset: 73447},
						val:        "[/:=@.$#%_]",
						chars:      []rune{'/', ':', '=', '@', '.', '$', '#', '%', '_'},
						ignoreCase: false,
						inverted:   false,
					},
					&litMatcher{
						pos:        position{line: 2543, col: 30, offset: 73461},
						val:        "-",
						ignoreCase: false,
						want:       "\"-\"",
					},
					&litMatcher{
						pos:        position{line: 2543, col: 36, offset: 73467},
						val:        "\\",
						ignoreCase: false,
						want:       "\"\\\\\"",
					},
				},
			},
		},
		{
			name: "NOT",
			pos:  position{line: 2547, col: 1, offset: 73623},
			expr: &seqExpr{
				pos: position{line: 2547, col: 8, offset: 73630},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2547, col: 8, offset: 73630},
						val:        "NOT",
						ignoreCase: false,
						want:       "\"NOT\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2547, col: 14, offset: 73636},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "OR",
			pos:  position{line: 2548, col: 1, offset: 73642},
			expr: &seqExpr{
				pos: position{line: 2548, col: 7, offset: 73648},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2548, col: 7, offset: 73648},
						name: "SPACE",
					},
					&litMatcher{
						pos:        position{line: 2548, col: 13, offset: 73654},
						val:        "OR",
						ignoreCase: false,
						want:       "\"OR\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2548, col: 18, offset: 73659},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "AND",
			pos:  position{line: 2549, col: 1, offset: 73665},
			expr: &seqExpr{
				pos: position{line: 2549, col: 8, offset: 73672},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2549, col: 8, offset: 73672},
						name: "SPACE",
					},
					&litMatcher{
						pos:        position{line: 2549, col: 14, offset: 73678},
						val:        "AND",
						ignoreCase: false,
						want:       "\"AND\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2549, col: 20, offset: 73684},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "PIPE",
			pos:  position{line: 2550, col: 1, offset: 73690},
			expr: &seqExpr{
				pos: position{line: 2550, col: 9, offset: 73698},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2550, col: 9, offset: 73698},
						name: "EMPTY_OR_SPACE",
					},
					&litMatcher{
						pos:        position{line: 2550, col: 24, offset: 73713},
						val:        "|",
						ignoreCase: false,
						want:       "\"|\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2550, col: 28, offset: 73717},
						name: "EMPTY_OR_SPACE",
					},
				},
			},
		},
		{
			name: "AS",
			pos:  position{line: 2551, col: 1, offset: 73732},
			expr: &seqExpr{
				pos: position{line: 2551, col: 7, offset: 73738},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2551, col: 7, offset: 73738},
						name: "SPACE",
					},
					&litMatcher{
						pos:        position{line: 2551, col: 13, offset: 73744},
						val:        "as",
						ignoreCase: true,
						want:       "\"AS\"i",
					},
					&ruleRefExpr{
						pos:  position{line: 2551, col: 19, offset: 73750},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "BY",
			pos:  position{line: 2552, col: 1, offset: 73776},
			expr: &seqExpr{
				pos: position{line: 2552, col: 7, offset: 73782},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2552, col: 7, offset: 73782},
						name: "SPACE",
					},
					&litMatcher{
						pos:        position{line: 2552, col: 13, offset: 73788},
						val:        "by",
						ignoreCase: true,
						want:       "\"BY\"i",
					},
					&ruleRefExpr{
						pos:  position{line: 2552, col: 19, offset: 73794},
						name: "SPACE",
					},
				},
			},
		},
		{
			name: "EQUAL",
			pos:  position{line: 2554, col: 1, offset: 73821},
			expr: &seqExpr{
				pos: position{line: 2554, col: 10, offset: 73830},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2554, col: 10, offset: 73830},
						name: "EMPTY_OR_SPACE",
					},
					&litMatcher{
						pos:        position{line: 2554, col: 25, offset: 73845},
						val:        "=",
						ignoreCase: false,
						want:       "\"=\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2554, col: 29, offset: 73849},
						name: "EMPTY_OR_SPACE",
					},
				},
			},
		},
		{
			name: "COMMA",
			pos:  position{line: 2555, col: 1, offset: 73864},
			expr: &seqExpr{
				pos: position{line: 2555, col: 10, offset: 73873},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2555, col: 10, offset: 73873},
						name: "EMPTY_OR_SPACE",
					},
					&litMatcher{
						pos:        position{line: 2555, col: 25, offset: 73888},
						val:        ",",
						ignoreCase: false,
						want:       "\",\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2555, col: 29, offset: 73892},
						name: "EMPTY_OR_SPACE",
					},
				},
			},
		},
		{
			name: "L_PAREN",
			pos:  position{line: 2556, col: 1, offset: 73907},
			expr: &seqExpr{
				pos: position{line: 2556, col: 12, offset: 73918},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2556, col: 12, offset: 73918},
						val:        "(",
						ignoreCase: false,
						want:       "\"(\"",
					},
					&ruleRefExpr{
						pos:  position{line: 2556, col: 16, offset: 73922},
						name: "EMPTY_OR_SPACE",
					},
				},
			},
		},
		{
			name: "R_PAREN",
			pos:  position{line: 2557, col: 1, offset: 73937},
			expr: &seqExpr{
				pos: position{line: 2557, col: 12, offset: 73948},
				exprs: []any{
					&ruleRefExpr{
						pos:  position{line: 2557, col: 12, offset: 73948},
						name: "EMPTY_OR_SPACE",
					},
					&litMatcher{
						pos:        position{line: 2557, col: 27, offset: 73963},
						val:        ")",
						ignoreCase: false,
						want:       "\")\"",
					},
				},
			},
		},
		{
			name: "EOF",
			pos:  position{line: 2559, col: 1, offset: 73968},
			expr: &notExpr{
				pos: position{line: 2559, col: 8, offset: 73975},
				expr: &anyMatcher{
					line: 2559, col: 9, offset: 73976,
				},
			},
		},
		{
			name: "SPACE",
			pos:  position{line: 2560, col: 1, offset: 73978},
			expr: &choiceExpr{
				pos: position{line: 2560, col: 10, offset: 73987},
				alternatives: []any{
					&seqExpr{
						pos: position{line: 2560, col: 11, offset: 73988},
						exprs: []any{
							&zeroOrOneExpr{
								pos: position{line: 2560, col: 11, offset: 73988},
								expr: &litMatcher{
									pos:        position{line: 2560, col: 11, offset: 73988},
									val:        " ",
									ignoreCase: false,
									want:       "\" \"",
								},
							},
							&ruleRefExpr{
								pos:  position{line: 2560, col: 16, offset: 73993},
								name: "COMMENT",
							},
							&zeroOrOneExpr{
								pos: position{line: 2560, col: 24, offset: 74001},
								expr: &litMatcher{
									pos:        position{line: 2560, col: 24, offset: 74001},
									val:        " ",
									ignoreCase: false,
									want:       "\" \"",
								},
							},
						},
					},
					&oneOrMoreExpr{
						pos: position{line: 2560, col: 32, offset: 74009},
						expr: &litMatcher{
							pos:        position{line: 2560, col: 32, offset: 74009},
							val:        " ",
							ignoreCase: false,
							want:       "\" \"",
						},
					},
				},
			},
		},
		{
			name: "COMMENT",
			pos:  position{line: 2561, col: 1, offset: 74014},
			expr: &seqExpr{
				pos: position{line: 2561, col: 12, offset: 74025},
				exprs: []any{
					&litMatcher{
						pos:        position{line: 2561, col: 12, offset: 74025},
						val:        "```",
						ignoreCase: false,
						want:       "\"```\"",
					},
					&zeroOrMoreExpr{
						pos: position{line: 2561, col: 18, offset: 74031},
						expr: &seqExpr{
							pos: position{line: 2561, col: 19, offset: 74032},
							exprs: []any{
								&notExpr{
									pos: position{line: 2561, col: 19, offset: 74032},
									expr: &litMatcher{
										pos:        position{line: 2561, col: 21, offset: 74034},
										val:        "```",
										ignoreCase: false,
										want:       "\"```\"",
									},
								},
								&anyMatcher{
									line: 2561, col: 28, offset: 74041,
								},
							},
						},
					},
					&litMatcher{
						pos:        position{line: 2561, col: 32, offset: 74045},
						val:        "```",
						ignoreCase: false,
						want:       "\"```\"",
					},
				},
			},
		},
		{
			name: "EMPTY_OR_SPACE",
			pos:  position{line: 2562, col: 1, offset: 74051},
			expr: &choiceExpr{
				pos: position{line: 2562, col: 20, offset: 74070},
				alternatives: []any{
					&ruleRefExpr{
						pos:  position{line: 2562, col: 20, offset: 74070},
						name: "SPACE",
					},
					&litMatcher{
						pos:        position{line: 2562, col: 28, offset: 74078},
						val:        "",
						ignoreCase: false,
						want:       "\"\"",
					},
				},
			},
		},
		{
			name: "EMPTY_OR_COMMA",
			pos:  position{line: 2563, col: 1, offset: 74081},
			expr: &choiceExpr{
				pos: position{line: 2563, col: 20, offset: 74100},
				alternatives: []any{
					&ruleRefExpr{
						pos:  position{line: 2563, col: 20, offset: 74100},
						name: "COMMA",
					},
					&ruleRefExpr{
						pos:  position{line: 2563, col: 28, offset: 74108},
						name: "EMPTY_OR_SPACE",
					},
				},
			},
		},
	},
}

func (c *current) onStart1(initialSearch, filterBlocks, queryAggBlocks any) (any, error) {
	var q ast.QueryStruct
	q.SearchFilter = initialSearch.(*ast.Node)

	// Join the InitialSearchBlock with the FilterBlocks with AND nodes. For a
	// search like "A | B | C | D" we should generate the node structure below
	// so that when we run the search it evaluates A first.
	//
	//      AND
	//     /   \
	//    A     AND
	//         /   \
	//        B     AND
	//             /   \
	//            C     D

	filterBlocksSlice := filterBlocks.([]any)
	switch len(filterBlocksSlice) {
	case 0:
		q.SearchFilter = initialSearch.(*ast.Node)
	case 1:
		q.SearchFilter = &ast.Node{
			NodeType: ast.NodeAnd,
			Left:     initialSearch.(*ast.Node),
			Right:    filterBlocksSlice[0].(*ast.Node),
		}
	default: // len > 1
		// Iterate backwards so we build the node structure mentioned above.
		root := filterBlocksSlice[len(filterBlocksSlice)-1].(*ast.Node)
		for i := len(filterBlocksSlice) - 2; i > -1; i-- {
			newRoot := &ast.Node{
				NodeType: ast.NodeAnd,
				Left:     filterBlocksSlice[i].(*ast.Node),
				Right:    root,
			}

			root = newRoot
		}

		q.SearchFilter = &ast.Node{
			NodeType: ast.NodeAnd,
			Left:     initialSearch.(*ast.Node),
			Right:    root,
		}
	}

	if queryAggBlocks != nil {
		queryAggSlice := queryAggBlocks.([]any)

		if len(queryAggSlice) > 0 {
			// Chain together all QueryAggergators.
			q.PipeCommands = queryAggSlice[0].(*structs.QueryAggregators)

			// Go to the end of the first chain.
			curQueryAgg := q.PipeCommands
			for ; curQueryAgg.Next != nil; curQueryAgg = curQueryAgg.Next {
			}

			// Link the remaining chains.
			for i := range queryAggSlice[1:] {
				queryAgg := queryAggSlice[i+1].(*structs.QueryAggregators)
				curQueryAgg.Next = queryAgg

				// Go to the end of this chain.
				for ; curQueryAgg.Next != nil; curQueryAgg = curQueryAgg.Next {
				}
			}
		}
	}

	return q, nil
}

func (p *parser) callonStart1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStart1(stack["initialSearch"], stack["filterBlocks"], stack["queryAggBlocks"])
}

func (c *current) onInitialSearchBlock1(clause any) (any, error) {
	return clause, nil
}

func (p *parser) callonInitialSearchBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onInitialSearchBlock1(stack["clause"])
}

func (c *current) onSearchBlock1(clause any) (any, error) {
	return clause, nil
}

func (p *parser) callonSearchBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSearchBlock1(stack["clause"])
}

func (c *current) onFilterBlock1(block any) (any, error) {
	return block, nil
}

func (p *parser) callonFilterBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFilterBlock1(stack["block"])
}

func (c *current) onQueryAggergatorBlock1(block any) (any, error) {
	queryAgg := block.(*structs.QueryAggregators)
	return queryAgg, nil
}

func (p *parser) callonQueryAggergatorBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onQueryAggergatorBlock1(stack["block"])
}

func (c *current) onFieldSelectBlock1(op, fields any) (any, error) {
	columnsRequest := &structs.ColumnsRequest{}
	if op == nil || string(op.([]byte)) == "+" {
		columnsRequest.IncludeColumns = fields.([]string)
	} else {
		columnsRequest.ExcludeColumns = fields.([]string)
	}

	queryAggregator := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			OutputColumns: columnsRequest,
		},
	}

	return queryAggregator, nil
}

func (p *parser) callonFieldSelectBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldSelectBlock1(stack["op"], stack["fields"])
}

func (c *current) onAggregatorBlock1(aggs, byFields any) (any, error) {
	aggNode := &structs.QueryAggregators{}

	// Extract the MeasureAggregators and check if any of the aggregation fields
	// need to be renamed.
	aggsSlice := aggs.([]*aggregator)
	measureAggs := make([]*structs.MeasureAggregator, len(aggsSlice))
	columnsRequest := &structs.ColumnsRequest{}
	columnsRequest.RenameAggregationColumns = make(map[string]string, 0)

	for i, agg := range aggsSlice {
		measureAggs[i] = agg.measureAgg

		if agg.renameOutputField {
			columnsRequest.RenameAggregationColumns[measureAggs[i].String()] = agg.outputFieldNewName
		}
	}

	// If any agg field was renamed, make a QueryAggregators for all the renames.
	if len(columnsRequest.RenameAggregationColumns) > 0 {
		renameNode := &structs.QueryAggregators{
			PipeCommandType: structs.OutputTransformType,
			OutputTransforms: &structs.OutputTransforms{
				OutputColumns: columnsRequest,
			},
		}

		aggNode.Next = renameNode
	}

	if byFields == nil {
		aggNode.PipeCommandType = structs.MeasureAggsType
		aggNode.MeasureOperations = measureAggs
	} else {
		aggNode.PipeCommandType = structs.GroupByType
		aggNode.GroupByRequest = &structs.GroupByRequest{
			MeasureOperations: measureAggs,
			GroupByColumns:    byFields.([]string),
		}
		aggNode.BucketLimit = query.MAX_GRP_BUCKS
	}

	return aggNode, nil
}

func (p *parser) callonAggregatorBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggregatorBlock1(stack["aggs"], stack["byFields"])
}

func (c *current) onGroupbyBlock1(fields any) (any, error) {
	// Wildcard fields are not allowed. See https://docs.splunk.com/Documentation/Splunk/9.1.0/SearchReference/Stats
	for _, field := range fields.([]string) {
		if strings.Contains(field, "*") {
			return nil, errors.New("BY clause cannot contain fields with wildcards")
		}
	}

	return fields, nil
}

func (p *parser) callonGroupbyBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onGroupbyBlock1(stack["fields"])
}

func (c *current) onRegexBlock1(keyAndOp, str any) (any, error) {
	var key, op string
	if keyAndOp == nil {
		key = "*"
		op = "="
	} else {
		keyAndOpSlice := keyAndOp.([]any)
		key = keyAndOpSlice[0].(string)
		op = keyAndOpSlice[1].(string)
	}

	// Remove the quotation marks.
	regex := str.(string)
	regex = regex[1 : len(regex)-1]

	node := &ast.Node{
		NodeType: ast.NodeTerminal,
		Comparison: ast.Comparison{
			Op:           op,
			Field:        key,
			Values:       regex,
			ValueIsRegex: true,
		},
	}

	return node, nil
}

func (p *parser) callonRegexBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRegexBlock1(stack["keyAndOp"], stack["str"])
}

func (c *current) onClauseLevel41(first, rest any) (any, error) {
	if rest == nil {
		return first, nil
	}

	cur := first.(*ast.Node)
	for _, v := range rest.([]any) {
		parts := v.([]any) // This will be [(AND / SPACE), ClauseLevel3].
		cur = &ast.Node{
			NodeType: ast.NodeAnd,
			Left:     cur,
			Right:    parts[1].(*ast.Node),
		}
	}

	return cur, nil
}

func (p *parser) callonClauseLevel41() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onClauseLevel41(stack["first"], stack["rest"])
}

func (c *current) onClauseLevel31(first, rest any) (any, error) {
	if rest == nil {
		return first, nil
	}

	cur := first.(*ast.Node)
	for _, v := range rest.([]any) {
		parts := v.([]any) // This will be [OR, ClauseLevel2].
		cur = &ast.Node{
			NodeType: ast.NodeOr,
			Left:     cur,
			Right:    parts[1].(*ast.Node),
		}
	}

	return cur, nil
}

func (p *parser) callonClauseLevel31() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onClauseLevel31(stack["first"], stack["rest"])
}

func (c *current) onClauseLevel22(notList, first any) (any, error) {
	// There's an issue with how queries with AST Not nodes are run, so use
	// De Morgan's law to manipulate the expression.
	node := first.(*ast.Node)
	numNots := len(notList.([]any))

	if numNots%2 == 1 {
		deMorgansLaw(node)
	}

	return node, nil
}

func (p *parser) callonClauseLevel22() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onClauseLevel22(stack["notList"], stack["first"])
}

func (c *current) onClauseLevel29(clause any) (any, error) {
	return clause, nil
}

func (p *parser) callonClauseLevel29() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onClauseLevel29(stack["clause"])
}

func (c *current) onClauseLevel12(clause any) (any, error) {
	return clause, nil
}

func (p *parser) callonClauseLevel12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onClauseLevel12(stack["clause"])
}

func (c *current) onClauseLevel18(term any) (any, error) {
	return term, nil
}

func (p *parser) callonClauseLevel18() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onClauseLevel18(stack["term"])
}

func (c *current) onSearchTerm1(term any) (any, error) {
	return term, nil
}

func (p *parser) callonSearchTerm1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSearchTerm1(stack["term"])
}

func (c *current) onTimechartBlock1(tcArgs, limitExpr any) (any, error) {
	aggNode := &structs.QueryAggregators{}

	columnsRequest := &structs.ColumnsRequest{}
	columnsRequest.RenameAggregationColumns = make(map[string]string, 0)
	measureAggs := make([]*structs.MeasureAggregator, 0)

	timechartExpr := &structs.TimechartExpr{}
	byField := ""

	if tcArgs == nil {
		return nil, fmt.Errorf("spl peg: timechart: either single-agg or eval-expression by split-by-clause is required")
	}

	timechartArgs := tcArgs.(*TimechartArgs)

	// Todo: Should add || timechartArgs.evalExpr == nil
	if timechartArgs.singleAggExpr == nil {
		return nil, fmt.Errorf("spl peg: timechart: either single-agg or eval-expression by split-by-clause is required")
	}

	var bOptions *structs.BinOptions

	if timechartArgs.tcOptions != nil {
		if timechartArgs.tcOptions.BinOptions != nil {
			bOptions = timechartArgs.tcOptions.BinOptions
		}
	}

	if timechartArgs.singleAggExpr != nil {
		singleAgg := &structs.SingleAgg{}
		aggTemp := timechartArgs.singleAggExpr

		for i, agg := range aggTemp.aggregators {
			measureAggs = append(measureAggs, agg.measureAgg)

			if agg.renameOutputField {
				measureAggs[i].StrEnc = agg.outputFieldNewName
			}
		}

		singleAgg.MeasureOperations = measureAggs
		timechartExpr.SingleAgg = singleAgg

		if aggTemp.SplitByClause != nil {
			byField = aggTemp.SplitByClause.Field
		}
	}

	// TODO: if timechartArgs.evalExpr != nil {}

	aggNode.PipeCommandType = structs.GroupByType
	aggNode.GroupByRequest = &structs.GroupByRequest{
		MeasureOperations: measureAggs,
		GroupByColumns:    []string{"timestamp"},
	}
	aggNode.BucketLimit = query.MAX_GRP_BUCKS

	if bOptions == nil {
		bOptions = &structs.BinOptions{
			SpanOptions: &structs.SpanOptions{
				DefaultSettings: true,
				SpanLength: &structs.SpanLength{
					Num:       1,
					TimeScalr: utils.TMMinute,
				},
			},
		}
	}

	var limitExprTmp *structs.LimitExpr
	if limitExpr != nil {
		limitExprTmp = limitExpr.(*structs.LimitExpr)
		if len(measureAggs) > 1 {
			limitExprTmp.LimitScoreMode = structs.LSMByFreq
		}
	}

	timeBucket := aggregations.InitTimeBucket(bOptions.SpanOptions.SpanLength.Num, bOptions.SpanOptions.SpanLength.TimeScalr, byField, limitExprTmp, len(measureAggs))
	aggNode.TimeHistogram = timeBucket

	return aggNode, nil
}

func (p *parser) callonTimechartBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTimechartBlock1(stack["tcArgs"], stack["limitExpr"])
}

func (c *current) onTimechartArgumentsList1(first, rest any) (any, error) {
	restSlice := rest.([]any)
	timechartArgs := &TimechartArgs{}

	numArgs := 1 + len(restSlice)

	for i := 0; i < numArgs; i++ {

		var numArg interface{}

		if i == 0 {
			numArg = first
		} else {
			numArg = restSlice[i-1].([]any)[1]
		}

		switch numArg.(type) {
		case *singleAggTemp:
			timechartArgs.singleAggExpr = numArg.(*singleAggTemp)
		case *structs.TcOptions:
			timechartArgs.tcOptions = numArg.(*structs.TcOptions)
		default:
			return nil, fmt.Errorf("Spl peg: Timechart: invalid timechart argument: %v", numArg)
		}
	}

	return timechartArgs, nil
}

func (p *parser) callonTimechartArgumentsList1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTimechartArgumentsList1(stack["first"], stack["rest"])
}

func (c *current) onTimechartArgument1(tcArg any) (any, error) {
	return tcArg, nil
}

func (p *parser) callonTimechartArgument1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTimechartArgument1(stack["tcArg"])
}

func (c *current) onSingleAggExpr1(aggs, splitByClause any) (any, error) {
	singleAggExpr := &singleAggTemp{
		aggregators: aggs.([]*aggregator),
	}

	if splitByClause != nil {
		singleAggExpr.SplitByClause = splitByClause.(*structs.SplitByClause)
	}

	return singleAggExpr, nil
}

func (p *parser) callonSingleAggExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSingleAggExpr1(stack["aggs"], stack["splitByClause"])
}

func (c *current) onSplitByClause1(field any) (any, error) {
	splitByClause := &structs.SplitByClause{
		Field: field.(string),
	}

	return splitByClause, nil
}

func (p *parser) callonSplitByClause1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSplitByClause1(stack["field"])
}

func (c *current) onTcOptions1(option any) (any, error) {
	//Default value
	tcOptions := &structs.TcOptions{
		UseNull:  true,
		UseOther: true,
		NullStr:  "null",
		OtherStr: "other",
	}
	switch option.(type) {
	case *structs.BinOptions:
		tcOptions.BinOptions = option.(*structs.BinOptions)
	case [][]string:
		optionSlice := option.([]any)
		for _, opt := range optionSlice {
			optArr := opt.([]string)
			switch optArr[0] {
			case "usenull":
				useNullBool, err := strconv.ParseBool(optArr[1])
				if err != nil {
					return nil, fmt.Errorf("Spl peg: Timechart: TcOptions: %v", err)
				}
				tcOptions.UseNull = useNullBool
			case "useother":
				useOtherBool, err := strconv.ParseBool(optArr[1])
				if err != nil {
					return nil, fmt.Errorf("Spl peg: Timechart: TcOptions: %v", err)
				}
				tcOptions.UseOther = useOtherBool
			case "nullstr":
				tcOptions.OtherStr = optArr[1]
			case "otherstr":
				tcOptions.OtherStr = optArr[1]
			default:
				return nil, fmt.Errorf("Spl peg: Timechart: TcOptions: invalid option: %v", optArr[0])
			}
		}
	default:
		return nil, fmt.Errorf("Spl peg: Timechart: Invalid tcOptions %v", option)
	}
	return tcOptions, nil
}

func (p *parser) callonTcOptions1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTcOptions1(stack["option"])
}

func (c *current) onTcOption1(tcOptionCMD, val any) (any, error) {
	tcOptionArr := []string{tcOptionCMD.(string), val.(string)}
	return tcOptionArr, nil
}

func (p *parser) callonTcOption1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTcOption1(stack["tcOptionCMD"], stack["val"])
}

func (c *current) onTcOptionCMD1(option any) (any, error) {
	optionStr, err := transferUint8ToString(option)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: Timechart: TcOptionCMD: %v", err)
	}
	return optionStr, nil
}

func (p *parser) callonTcOptionCMD1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTcOptionCMD1(stack["option"])
}

func (c *current) onBinOptions1(spanOptions any) (any, error) {
	binOptions := &structs.BinOptions{
		SpanOptions: spanOptions.(*structs.SpanOptions),
	}
	return binOptions, nil
}

func (p *parser) callonBinOptions1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBinOptions1(stack["spanOptions"])
}

func (c *current) onSpanOptions1(spanLength any) (any, error) {
	spanOptions := &structs.SpanOptions{
		SpanLength: spanLength.(*structs.SpanLength),
	}
	return spanOptions, nil
}

func (p *parser) callonSpanOptions1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSpanOptions1(stack["spanLength"])
}

func (c *current) onSpanLength1(intAsStr, timeScale any) (any, error) {
	num, err := strconv.Atoi(intAsStr.(string))
	if err != nil {
		return nil, fmt.Errorf("SpanLength: Invalid num (%v): %v", intAsStr.(string), err)
	}

	spanLength := &structs.SpanLength{
		Num:       num,
		TimeScalr: timeScale.(utils.TimeUnit),
	}
	return spanLength, nil
}

func (p *parser) callonSpanLength1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSpanLength1(stack["intAsStr"], stack["timeScale"])
}

func (c *current) onTimeScale1(timeUnit any) (any, error) {
	return timeUnit, nil
}

func (p *parser) callonTimeScale1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTimeScale1(stack["timeUnit"])
}

func (c *current) onLimitExpr1(sortBy, intAsStr any) (any, error) {
	num, err := strconv.Atoi(intAsStr.(string))
	if err != nil {
		return nil, fmt.Errorf("SpanLength: Invalid num (%v): %v", intAsStr.(string), err)
	}

	limitExpr := &structs.LimitExpr{
		IsTop: true, // Default Value
		Num:   num,
	}

	if sortBy != nil {
		sortByStr, err := transferUint8ToString(sortBy)
		if err != nil {
			return nil, fmt.Errorf("Spl peg: Timechart: %v", err)
		}
		if sortByStr == "bottom" {
			limitExpr.IsTop = false
		}
	}

	return limitExpr, nil
}

func (p *parser) callonLimitExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLimitExpr1(stack["sortBy"], stack["intAsStr"])
}

func (c *current) onStatisticBlock1(statisticExpr any) (any, error) {
	letColReq := &structs.LetColumnsRequest{
		StatisticColRequest: statisticExpr.(*structs.StatisticExpr),
	}

	root := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			LetColumns: letColReq,
		},
	}

	measureAgg := &structs.MeasureAggregator{
		MeasureCol:  "*",
		MeasureFunc: utils.Count,
	}

	measureOperations := make([]*structs.MeasureAggregator, 1)
	measureOperations[0] = measureAgg

	groupByColumns := append(statisticExpr.(*structs.StatisticExpr).FieldList, statisticExpr.(*structs.StatisticExpr).ByClause...)

	aggNode := &structs.QueryAggregators{}
	aggNode.Next = root
	aggNode.PipeCommandType = structs.GroupByType
	aggNode.GroupByRequest = &structs.GroupByRequest{
		MeasureOperations: measureOperations,
		GroupByColumns:    groupByColumns,
	}

	return aggNode, nil
}

func (p *parser) callonStatisticBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticBlock1(stack["statisticExpr"])
}

func (c *current) onStatisticExpr1(cmd, limit, fieldList, byClause, options any) (any, error) {

	statisticExpr := &structs.StatisticExpr{
		FieldList: fieldList.([]interface{})[1].([]string),
	}

	statisticCmd, err := transferUint8ToString(cmd)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: StatisticExpr: %v", err)
	}

	if statisticCmd == "top" {
		statisticExpr.StatisticFunctionMode = structs.SFMTop
	} else {
		statisticExpr.StatisticFunctionMode = structs.SFMRare
	}

	if limit != nil {
		statisticExpr.Limit = limit.(string)
	}

	if options != nil {
		statisticExpr.StatisticOptions = options.(*structs.StatisticOptions)
	} else {
		statisticExpr.StatisticOptions = &structs.StatisticOptions{
			ShowCount:    true,
			CountField:   "count",
			ShowPerc:     true,
			PercentField: "percent",
			UseOther:     false,
			OtherStr:     "Other",
		}
	}

	if byClause != nil {
		statisticExpr.ByClause = byClause.([]string)
	}

	return statisticExpr, nil
}

func (p *parser) callonStatisticExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticExpr1(stack["cmd"], stack["limit"], stack["fieldList"], stack["byClause"], stack["options"])
}

func (c *current) onStatisticLimit2(number any) (any, error) {
	return number.(string), nil
}

func (p *parser) callonStatisticLimit2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticLimit2(stack["number"])
}

func (c *current) onStatisticLimit7(limit any) (any, error) {
	return limit.(string), nil
}

func (p *parser) callonStatisticLimit7() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticLimit7(stack["limit"])
}

func (c *current) onStatisticOptions1(option any) (any, error) {
	//Default value
	options := &structs.StatisticOptions{
		ShowCount:    true,
		CountField:   "count",
		ShowPerc:     true,
		PercentField: "percent",
		UseOther:     false,
		OtherStr:     "other",
	}

	optionSlice := option.([]any)
	for _, opt := range optionSlice {
		optArr := opt.([]string)
		// Check for matching option types
		switch optArr[0] {
		case "showcount":
			showCountBool, err := strconv.ParseBool(optArr[1])
			if err != nil {
				return nil, fmt.Errorf("Spl peg: StatisticBlock: Options: %v", err)
			}
			options.ShowCount = showCountBool
		case "countfield":
			options.CountField = optArr[1]
		case "showperc":
			showPercBool, err := strconv.ParseBool(optArr[1])
			if err != nil {
				return nil, fmt.Errorf("Spl peg: StatisticBlock: Options: %v", err)
			}
			options.ShowPerc = showPercBool
		case "percentfield":
			options.PercentField = optArr[1]
		case "useother":
			useOtherBool, err := strconv.ParseBool(optArr[1])
			if err != nil {
				return nil, fmt.Errorf("Spl peg: StatisticBlock: Options: %v", err)
			}
			options.UseOther = useOtherBool
		case "otherstr":
			options.OtherStr = optArr[1]
		default:
			return nil, fmt.Errorf("Spl peg: StatisticBlock: Options: invalid option")
		}
	}

	return options, nil
}

func (p *parser) callonStatisticOptions1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticOptions1(stack["option"])
}

func (c *current) onStatisticOption1(optionCMD, field any) (any, error) {
	optionArr := []string{optionCMD.(string), field.(string)}
	return optionArr, nil
}

func (p *parser) callonStatisticOption1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticOption1(stack["optionCMD"], stack["field"])
}

func (c *current) onStatisticOptionCMD1(option any) (any, error) {
	optionStr, err := transferUint8ToString(option)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: StatisticExpr: %v", err)
	}
	return optionStr, nil
}

func (p *parser) callonStatisticOptionCMD1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStatisticOptionCMD1(stack["option"])
}

func (c *current) onByClause2(fieldList any) (any, error) {
	return fieldList.([]string), nil
}

func (p *parser) callonByClause2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onByClause2(stack["fieldList"])
}

func (c *current) onByClause7(groupByBlock any) (any, error) {
	return groupByBlock.([]string), nil
}

func (p *parser) callonByClause7() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onByClause7(stack["groupByBlock"])
}

func (c *current) onDedupBlock1(dedupExpr any) (any, error) {

	letColReq := &structs.LetColumnsRequest{
		DedupColRequest: dedupExpr.(*structs.DedupExpr),
	}

	root := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			LetColumns: letColReq,
		},
	}

	return root, nil
}

func (p *parser) callonDedupBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupBlock1(stack["dedupExpr"])
}

func (c *current) onDedupExpr1(limitArr, options1, fieldList, options2, sortByClause any) (any, error) {
	dedupExpr := &structs.DedupExpr{
		FieldList:         fieldList.([]string),
		Limit:             1,
		DedupCombinations: make(map[string]map[int][]structs.SortValue, 0),
		DedupRecords:      make(map[string]map[string]interface{}, 0),
	}

	if limitArr != nil {
		limitStr := limitArr.([]interface{})[1].(string)
		limit, err := strconv.ParseUint(limitStr, 10, 64)
		if err != nil || limit == 0 {
			return nil, fmt.Errorf("Invalid limit (%v): %v", limitStr, err)
		}
		dedupExpr.Limit = limit
	}

	dedupExpr.DedupOptions = &structs.DedupOptions{
		Consecutive: false,
		KeepEmpty:   false,
		KeepEvents:  false,
	}

	if options1 != nil {
		dedupExpr.DedupOptions = options1.(*structs.DedupOptions)
	}
	if options2 != nil {
		options := options2.(*structs.DedupOptions)

		if options.Consecutive {
			dedupExpr.DedupOptions.Consecutive = options.Consecutive
		}
		if options.KeepEmpty {
			dedupExpr.DedupOptions.KeepEmpty = options.KeepEmpty
		}
		if options.KeepEvents {
			dedupExpr.DedupOptions.KeepEvents = options.KeepEvents
		}
	}

	if sortByClause != nil {
		dedupExpr.DedupSortEles = sortByClause.([]*structs.SortElement)

		// Make the DedupSortAscending from the DedupSortEles.
		dedupExpr.DedupSortAscending = make([]int, len(dedupExpr.DedupSortEles))
		for i, ele := range dedupExpr.DedupSortEles {
			if ele.SortByAsc {
				dedupExpr.DedupSortAscending[i] = 1
			} else {
				dedupExpr.DedupSortAscending[i] = -1
			}
		}
	}

	return dedupExpr, nil
}

func (p *parser) callonDedupExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupExpr1(stack["limitArr"], stack["options1"], stack["fieldList"], stack["options2"], stack["sortByClause"])
}

func (c *current) onDedupFieldName1(field any) (any, error) {
	return field, nil
}

func (p *parser) callonDedupFieldName1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupFieldName1(stack["field"])
}

func (c *current) onDedupFieldList1(first, rest any) (any, error) {
	// Convert `rest` to a slice. Each element of the slice will be a 2-element
	// slice where the first element is " " and the second is a FieldName.
	restSlice := rest.([]any)

	numFieldNames := 1 + len(restSlice)
	fields := make([]string, numFieldNames)
	fields[0] = first.(string)

	for i := 1; i < numFieldNames; i++ {
		separatorAndField := restSlice[i-1].([]any)
		fields[i] = separatorAndField[1].(string)
	}

	return fields, nil
}

func (p *parser) callonDedupFieldList1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupFieldList1(stack["first"], stack["rest"])
}

func (c *current) onDedupOptions1(option any) (any, error) {
	//Default value
	options := &structs.DedupOptions{
		Consecutive: false,
		KeepEmpty:   false,
		KeepEvents:  false,
	}

	optionSlice := option.([]any)
	for _, opt := range optionSlice {
		optArr := opt.([]string)
		// Check for matching option types
		switch optArr[0] {
		case "consecutive":
			consecutiveBool, err := strconv.ParseBool(optArr[1])
			if err != nil {
				return nil, fmt.Errorf("Spl peg: DedupBlock: Options: %v", err)
			}
			options.Consecutive = consecutiveBool
		case "keepempty":
			keepEmptyBool, err := strconv.ParseBool(optArr[1])
			if err != nil {
				return nil, fmt.Errorf("Spl peg: DedupBlock: Options: %v", err)
			}
			options.KeepEmpty = keepEmptyBool
		case "keepevents":
			keepEventsBool, err := strconv.ParseBool(optArr[1])
			if err != nil {
				return nil, fmt.Errorf("Spl peg: DedupBlock: Options: %v", err)
			}
			options.KeepEvents = keepEventsBool
		default:
			return nil, fmt.Errorf("Spl peg: DedupBlock: Options: invalid option")
		}
	}

	return options, nil
}

func (p *parser) callonDedupOptions1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupOptions1(stack["option"])
}

func (c *current) onDedupOption1(optionCMD, field any) (any, error) {
	optionArr := []string{optionCMD.(string), field.(string)}
	return optionArr, nil
}

func (p *parser) callonDedupOption1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupOption1(stack["optionCMD"], stack["field"])
}

func (c *current) onDedupOptionCMD1(option any) (any, error) {
	optionStr, err := transferUint8ToString(option)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: DedupExpr: %v", err)
	}
	return optionStr, nil
}

func (p *parser) callonDedupOptionCMD1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupOptionCMD1(stack["option"])
}

func (c *current) onDedupSortByClause1(dedupSortEles any) (any, error) {
	return dedupSortEles, nil
}

func (p *parser) callonDedupSortByClause1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDedupSortByClause1(stack["dedupSortEles"])
}

func (c *current) onSortElements1(first, rest any) (any, error) {
	restSlice := rest.([]any)

	length := 1 + len(restSlice)
	sortEles := make([]*structs.SortElement, length)
	sortEles[0] = first.(*structs.SortElement)

	for i := 1; i < length; i++ {
		elements := restSlice[i-1].([]any)
		sortEles[i] = elements[1].(*structs.SortElement)
	}

	return sortEles, nil
}

func (p *parser) callonSortElements1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSortElements1(stack["first"], stack["rest"])
}

func (c *current) onSingleSortElement1(element any) (any, error) {
	return element, nil
}

func (p *parser) callonSingleSortElement1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSingleSortElement1(stack["element"])
}

func (c *current) onSingleSortElementWithoutCast1(sortBySymbol, field any) (any, error) {
	sortByAsc := true

	symbol := sortBySymbol.([]byte)
	if len(symbol) > 0 && symbol[0] == '-' {
		sortByAsc = false
	}

	return &structs.SortElement{
		SortByAsc: sortByAsc,
		Op:        "",
		Field:     field.(string),
	}, nil
}

func (p *parser) callonSingleSortElementWithoutCast1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSingleSortElementWithoutCast1(stack["sortBySymbol"], stack["field"])
}

func (c *current) onSingleSortElementWithCast1(sortBySymbol, op, field any) (any, error) {
	sortByAsc := true

	symbol := sortBySymbol.([]byte)
	if len(symbol) > 0 && symbol[0] == '-' {
		sortByAsc = false
	}

	opStr, err := transferUint8ToString(op)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: singleSortElementWithCast: %v", err)
	}

	return &structs.SortElement{
		SortByAsc: sortByAsc,
		Op:        opStr,
		Field:     field.(string),
	}, nil
}

func (p *parser) callonSingleSortElementWithCast1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSingleSortElementWithCast1(stack["sortBySymbol"], stack["op"], stack["field"])
}

func (c *current) onRenameBlock1(renameExpr any) (any, error) {
	letColReq := &structs.LetColumnsRequest{
		RenameColRequest: renameExpr.(*structs.RenameExpr),
	}

	root := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			LetColumns: letColReq,
		},
	}

	return root, nil
}

func (p *parser) callonRenameBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRenameBlock1(stack["renameExpr"])
}

func (c *current) onRenameExpr2(originalPattern, newPattern any) (any, error) {
	renameExpr := &structs.RenameExpr{
		RenameExprMode:  structs.REMPhrase,
		OriginalPattern: originalPattern.(string),
		NewPattern:      removeQuotes(newPattern),
	}

	return renameExpr, nil
}

func (p *parser) callonRenameExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRenameExpr2(stack["originalPattern"], stack["newPattern"])
}

func (c *current) onRenameExpr9(originalPattern, newPattern any) (any, error) {
	isRegex, err := isRegexRename(originalPattern.(string), newPattern.(string))
	if err != nil {
		return nil, fmt.Errorf("Spl peg: RenameExpr: %v", err)
	}

	var renameExprMode structs.RenameExprMode
	if isRegex {
		renameExprMode = structs.REMRegex
	} else {
		renameExprMode = structs.REMOverride
	}

	renameExpr := &structs.RenameExpr{
		RenameExprMode:  renameExprMode,
		OriginalPattern: originalPattern.(string),
		NewPattern:      newPattern.(string),
	}

	return renameExpr, nil
}

func (p *parser) callonRenameExpr9() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRenameExpr9(stack["originalPattern"], stack["newPattern"])
}

func (c *current) onRexBlock1(field, str any) (any, error) {
	pattern := removeQuotes(str)
	rexColNames, err := getRexColNames(pattern)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: RexBlock: %v", err)
	}
	rexExpr := &structs.RexExpr{
		FieldName:   field.(string),
		Pattern:     transferPCREToRE2(pattern),
		RexColNames: rexColNames,
	}

	letColReq := &structs.LetColumnsRequest{
		RexColRequest: rexExpr,
	}

	root := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			LetColumns: letColReq,
		},
	}

	return root, nil
}

func (p *parser) callonRexBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRexBlock1(stack["field"], stack["str"])
}

func (c *current) onSortBlock1(sortByEles any) (any, error) {

	sortExpr := &structs.SortExpr{
		SortEles:    sortByEles.([]*structs.SortElement),
		SortRecords: make(map[string]map[string]interface{}, 0),
	}

	ascendingArr := make([]int, len(sortExpr.SortEles))
	for i, ele := range sortExpr.SortEles {
		if ele.SortByAsc {
			ascendingArr[i] = 1
		} else {
			ascendingArr[i] = -1
		}
	}

	sortExpr.SortAscending = ascendingArr

	letColReq := &structs.LetColumnsRequest{
		SortColRequest: sortExpr,
	}

	root := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			LetColumns: letColReq,
		},
	}

	return root, nil
}

func (p *parser) callonSortBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSortBlock1(stack["sortByEles"])
}

func (c *current) onEvalBlock1(first, rest any) (any, error) {
	root := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			LetColumns: first.(*structs.LetColumnsRequest),
		},
	}

	leafQueryAgg := root
	restSlice := rest.([]any)
	for i := range restSlice {
		CommaSpaceAndEval := restSlice[i].([]any)
		nextQueryAgg := &structs.QueryAggregators{
			PipeCommandType: structs.OutputTransformType,
			OutputTransforms: &structs.OutputTransforms{
				LetColumns: CommaSpaceAndEval[1].(*structs.LetColumnsRequest),
			},
		}

		leafQueryAgg.Next = nextQueryAgg
		leafQueryAgg = leafQueryAgg.Next
	}

	return root, nil
}

func (p *parser) callonEvalBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEvalBlock1(stack["first"], stack["rest"])
}

func (c *current) onSingleEval1(field, expr any) (any, error) {
	fieldStr := field.(string)
	if strings.Contains(fieldStr, "*") {
		return nil, fmt.Errorf("New fields must not contain wildcards; invalid field: %v", field)
	}

	letColumnsRequest := expr.(*structs.LetColumnsRequest)
	letColumnsRequest.NewColName = fieldStr

	return letColumnsRequest, nil
}

func (p *parser) callonSingleEval1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSingleEval1(stack["field"], stack["expr"])
}

func (c *current) onEvalExpression1(value any) (any, error) {
	letColReq := &structs.LetColumnsRequest{
		ValueColRequest: value.(*structs.ValueExpr),
	}

	return letColReq, nil
}

func (p *parser) callonEvalExpression1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEvalExpression1(stack["value"])
}

func (c *current) onConditionExpr1(condition, trueValue, falseValue any) (any, error) {

	node := &structs.ConditionExpr{
		Op:         "if",
		BoolExpr:   condition.(*structs.BoolExpr),
		TrueValue:  trueValue.(*structs.ValueExpr),
		FalseValue: falseValue.(*structs.ValueExpr),
	}

	return node, nil
}

func (p *parser) callonConditionExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConditionExpr1(stack["condition"], stack["trueValue"], stack["falseValue"])
}

func (c *current) onTextExpr2(opName, stringExpr any) (any, error) {
	opNameStr, err := transferUint8ToString(opName)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: TextExpr: %v", err)
	}
	node := &structs.TextExpr{
		Op:          opNameStr,
		Value:       stringExpr.(*structs.StringExpr),
		StrToRemove: "",
	}

	return node, nil
}

func (p *parser) callonTextExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr2(stack["opName"], stack["stringExpr"])
}

func (c *current) onTextExpr10(opName, firstVal, rest any) (any, error) {
	opNameStr, err := transferUint8ToString(opName)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: TextExpr: %v", err)
	}
	if rest == nil {
		return firstVal, nil
	}
	restSlice := rest.([]any)
	values := make([]*structs.StringExpr, 1+len(restSlice))
	values[0] = firstVal.(*structs.StringExpr)

	for i := range restSlice {
		stringAtom := restSlice[i].([]any)
		values[i+1] = stringAtom[1].(*structs.StringExpr)
	}
	node := &structs.TextExpr{
		Op:           opNameStr,
		MaxMinValues: values,
	}
	return node, nil

}

func (p *parser) callonTextExpr10() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr10(stack["opName"], stack["firstVal"], stack["rest"])
}

func (c *current) onTextExpr25(opName, url any) (any, error) {
	opNameStr, err := transferUint8ToString(opName)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: TextExpr: %v", err)
	}
	node := &structs.TextExpr{
		Op:          opNameStr,
		Value:       url.(*structs.StringExpr),
		StrToRemove: "",
	}
	return node, nil

}

func (p *parser) callonTextExpr25() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr25(stack["opName"], stack["url"])
}

func (c *current) onTextExpr33(opName, stringExpr, delim any) (any, error) {
	opNameStr, err := transferUint8ToString(opName)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: TextExpr: %v", err)
	}
	node := &structs.TextExpr{
		Op:        opNameStr,
		Value:     stringExpr.(*structs.StringExpr),
		Delimiter: delim.(*structs.StringExpr),
	}
	return node, nil
}

func (p *parser) callonTextExpr33() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr33(stack["opName"], stack["stringExpr"], stack["delim"])
}

func (c *current) onTextExpr44(opName, stringExpr, startIndex, lengthParam any) (any, error) {
	opNameStr, err := transferUint8ToString(opName)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: TextExpr: %v", err)
	}
	stringExprConverted, ok := stringExpr.(*structs.StringExpr)
	if !ok {
		return nil, fmt.Errorf("Spl peg: TextExpr: Failed to assert stringExpr as *structs.StringExpr")
	}
	startIndexConverted, ok := startIndex.(*structs.NumericExpr)
	if !ok {
		return nil, fmt.Errorf("Spl peg: TextExpr: Failed to assert startIndex as *structs.NumericExpr")
	}
	var lengthConverted *structs.NumericExpr
	if lengthParam != nil {
		lengthSlice, ok := lengthParam.([]interface{})
		if ok && len(lengthSlice) > 1 {
			length, ok := lengthSlice[1].(*structs.NumericExpr)
			if ok {
				lengthConverted = length
			} else {
				return nil, fmt.Errorf("Spl peg: TextExpr: Unable to assert length as *structs.NumericExpr")
			}
		}
	}
	node := &structs.TextExpr{
		Op:         opNameStr,
		Value:      stringExprConverted,
		StartIndex: startIndexConverted,
		LengthExpr: lengthConverted,
	}
	return node, nil
}

func (p *parser) callonTextExpr44() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr44(stack["opName"], stack["stringExpr"], stack["startIndex"], stack["lengthParam"])
}

func (c *current) onTextExpr60(value, format any) (any, error) {
	var formatExpr *structs.StringExpr
	if format != nil {
		formatSlice := format.([]interface{})
		formatExpr, _ = formatSlice[1].(*structs.StringExpr)
	}
	return &structs.TextExpr{
		IsTerminal: false,
		Op:         "tostring",
		Val:        value.(*structs.ValueExpr),
		Format:     formatExpr,
	}, nil
}

func (p *parser) callonTextExpr60() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr60(stack["value"], stack["format"])
}

func (c *current) onTextExpr72(opName, expr, strToRemoveExpr any) (any, error) {
	opNameStr, err := transferUint8ToString(opName)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: TextExpr: %v", err)
	}

	stringExpr, ok := expr.(*structs.StringExpr)
	if !ok {
		return nil, fmt.Errorf("Spl peg: TextExpr: Failed to assert expr as *structs.StringExpr: %v", err)
	}

	strToRemove := " \t"
	if strToRemoveExpr != nil {
		strToRemove = strToRemoveExpr.(string)
	}

	node := &structs.TextExpr{
		Op:          opNameStr,
		Value:       stringExpr,
		StrToRemove: removeQuotes(strToRemove),
	}

	return node, nil
}

func (p *parser) callonTextExpr72() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTextExpr72(stack["opName"], stack["expr"], stack["strToRemoveExpr"])
}

func (c *current) onStrToRemoveExpr1(strToRemove any) (any, error) {
	return strToRemove, nil
}

func (p *parser) callonStrToRemoveExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStrToRemoveExpr1(stack["strToRemove"])
}

func (c *current) onEvalFieldToRead2() (any, error) {
	return string(c.text), nil
}

func (p *parser) callonEvalFieldToRead2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEvalFieldToRead2()
}

func (c *current) onEvalFieldToRead8(field any) (any, error) {
	return field, nil
}

func (p *parser) callonEvalFieldToRead8() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEvalFieldToRead8(stack["field"])
}

func (c *current) onWhereBlock1(condition any) (any, error) {
	queryAgg := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			FilterRows: condition.(*structs.BoolExpr),
		},
	}

	return queryAgg, nil
}

func (p *parser) callonWhereBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onWhereBlock1(stack["condition"])
}

func (c *current) onBoolExpr1(expr any) (any, error) {
	return expr, nil
}

func (p *parser) callonBoolExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExpr1(stack["expr"])
}

func (c *current) onBoolExprLevel41(first, rest any) (any, error) {
	if rest == nil {
		return first, nil
	}

	cur := first.(*structs.BoolExpr)
	for _, v := range rest.([]any) {
		opAndClause := v.([]any)
		cur = &structs.BoolExpr{
			IsTerminal: false,
			BoolOp:     structs.BoolOpOr,
			LeftBool:   cur,
			RightBool:  opAndClause[1].(*structs.BoolExpr),
		}
	}

	return cur, nil
}

func (p *parser) callonBoolExprLevel41() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel41(stack["first"], stack["rest"])
}

func (c *current) onBoolExprLevel31(first, rest any) (any, error) {
	if rest == nil {
		return first, nil
	}

	cur := first.(*structs.BoolExpr)
	for _, v := range rest.([]any) {
		opAndClause := v.([]any)
		cur = &structs.BoolExpr{
			IsTerminal: false,
			BoolOp:     structs.BoolOpAnd,
			LeftBool:   cur,
			RightBool:  opAndClause[1].(*structs.BoolExpr),
		}
	}

	return cur, nil
}

func (p *parser) callonBoolExprLevel31() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel31(stack["first"], stack["rest"])
}

func (c *current) onBoolExprLevel22(first any) (any, error) {
	cur := &structs.BoolExpr{
		IsTerminal: false,
		BoolOp:     structs.BoolOpNot,
		LeftBool:   first.(*structs.BoolExpr),
		RightBool:  nil,
	}

	return cur, nil
}

func (p *parser) callonBoolExprLevel22() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel22(stack["first"])
}

func (c *current) onBoolExprLevel29(first any) (any, error) {
	return first, nil
}

func (p *parser) callonBoolExprLevel29() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel29(stack["first"])
}

func (c *current) onBoolExprLevel12(first any) (any, error) {
	return first, nil
}

func (p *parser) callonBoolExprLevel12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel12(stack["first"])
}

func (c *current) onBoolExprLevel18(op, value any) (any, error) {
	opNameStr, err := transferUint8ToString(op)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: BoolExpr: %v", err)
	}
	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  value.(*structs.ValueExpr),
		RightValue: nil,
		ValueOp:    opNameStr,
	}
	return expr, nil
}

func (p *parser) callonBoolExprLevel18() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel18(stack["op"], stack["value"])
}

func (c *current) onBoolExprLevel120(likeExpr any) (any, error) {
	return likeExpr, nil
}

func (p *parser) callonBoolExprLevel120() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolExprLevel120(stack["likeExpr"])
}

func (c *current) onLikeExpr2(left, right any) (any, error) {
	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  left.(*structs.ValueExpr),
		RightValue: right.(*structs.ValueExpr),
		ValueOp:    "like",
	}
	return expr, nil
}

func (p *parser) callonLikeExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLikeExpr2(stack["left"], stack["right"])
}

func (c *current) onLikeExpr11(stringr, pattern any) (any, error) {
	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  stringr.(*structs.ValueExpr),
		RightValue: pattern.(*structs.ValueExpr),
		ValueOp:    "like",
	}
	return expr, nil

}

func (p *parser) callonLikeExpr11() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLikeExpr11(stack["stringr"], stack["pattern"])
}

func (c *current) onLikeExpr21(stringVal, pattern any) (any, error) {
	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  stringVal.(*structs.ValueExpr),
		RightValue: pattern.(*structs.ValueExpr),
		ValueOp:    "match",
	}
	return expr, nil

}

func (p *parser) callonLikeExpr21() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLikeExpr21(stack["stringVal"], stack["pattern"])
}

func (c *current) onLikeExpr31(cidr, ip any) (any, error) {
	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  cidr.(*structs.ValueExpr),
		RightValue: ip.(*structs.ValueExpr),
		ValueOp:    "cidrmatch",
	}
	return expr, nil
}

func (p *parser) callonLikeExpr31() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLikeExpr31(stack["cidr"], stack["ip"])
}

func (c *current) onLikeExpr41(inExpr any) (any, error) {
	return inExpr, nil
}

func (p *parser) callonLikeExpr41() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLikeExpr41(stack["inExpr"])
}

func (c *current) onLikeExpr44(boolComparisonExpr any) (any, error) {
	return boolComparisonExpr, nil
}

func (p *parser) callonLikeExpr44() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLikeExpr44(stack["boolComparisonExpr"])
}

func (c *current) onBoolComparisonExpr1(left, op, right any) (any, error) {
	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  left.(*structs.ValueExpr),
		RightValue: right.(*structs.ValueExpr),
		ValueOp:    op.(string),
	}

	return expr, nil
}

func (p *parser) callonBoolComparisonExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolComparisonExpr1(stack["left"], stack["op"], stack["right"])
}

func (c *current) onInExpr2(left, valueToJudge, rest any) (any, error) {
	restSlice := rest.([]any)
	slice := make([]*structs.ValueExpr, 1+len(restSlice))
	slice[0] = valueToJudge.(*structs.ValueExpr)

	for i := range restSlice {
		valueAtom := restSlice[i].([]any)
		slice[i+1] = valueAtom[1].(*structs.ValueExpr)
	}

	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  left.(*structs.ValueExpr),
		ValueList:  slice,
		ValueOp:    "in",
	}
	return expr, nil
}

func (p *parser) callonInExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onInExpr2(stack["left"], stack["valueToJudge"], stack["rest"])
}

func (c *current) onInExpr17(valueToJudge, rest any) (any, error) {
	restSlice := rest.([]any)
	slice := make([]*structs.ValueExpr, len(restSlice))

	for i := range restSlice {
		valueAtom := restSlice[i].([]any)
		slice[i] = valueAtom[1].(*structs.ValueExpr)
	}

	expr := &structs.BoolExpr{
		IsTerminal: true,
		LeftValue:  valueToJudge.(*structs.ValueExpr),
		ValueList:  slice,
		ValueOp:    "in",
	}
	return expr, nil
}

func (p *parser) callonInExpr17() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onInExpr17(stack["valueToJudge"], stack["rest"])
}

func (c *current) onValueExpr2(condition any) (any, error) {

	expr := &structs.ValueExpr{
		ValueExprMode: structs.VEMConditionExpr,
		ConditionExpr: condition.(*structs.ConditionExpr),
	}

	return expr, nil
}

func (p *parser) callonValueExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onValueExpr2(stack["condition"])
}

func (c *current) onValueExpr5(condition any) (any, error) {

	expr := &structs.ValueExpr{
		ValueExprMode: structs.VEMConditionExpr,
		ConditionExpr: condition.(*structs.ConditionExpr),
	}

	return expr, nil
}

func (p *parser) callonValueExpr5() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onValueExpr5(stack["condition"])
}

func (c *current) onValueExpr11(numeric any) (any, error) {

	expr := &structs.ValueExpr{
		ValueExprMode: structs.VEMNumericExpr,
		NumericExpr:   numeric.(*structs.NumericExpr),
	}

	return expr, nil
}

func (p *parser) callonValueExpr11() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onValueExpr11(stack["numeric"])
}

func (c *current) onValueExpr14(str any) (any, error) {

	expr := &structs.ValueExpr{
		ValueExprMode: structs.VEMStringExpr,
		StringExpr:    str.(*structs.StringExpr),
	}

	return expr, nil
}

func (p *parser) callonValueExpr14() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onValueExpr14(stack["str"])
}

func (c *current) onValueExpr17(str any) (any, error) {

	expr := &structs.ValueExpr{
		ValueExprMode: structs.VEMStringExpr,
		StringExpr:    str.(*structs.StringExpr),
	}

	return expr, nil
}

func (p *parser) callonValueExpr17() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onValueExpr17(stack["str"])
}

func (c *current) onValueExpr23(boolean any) (any, error) {

	expr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolean.(*structs.BoolExpr),
	}

	return expr, nil
}

func (p *parser) callonValueExpr23() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onValueExpr23(stack["boolean"])
}

func (c *current) onStringExpr2(text any) (any, error) {
	expr := &structs.StringExpr{
		StringExprMode: structs.SEMTextExpr,
		TextExpr:       text.(*structs.TextExpr),
	}

	return expr, nil
}

func (p *parser) callonStringExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStringExpr2(stack["text"])
}

func (c *current) onStringExpr8(str any) (any, error) {
	expr := &structs.StringExpr{
		StringExprMode: structs.SEMRawString,
		RawString:      removeQuotes(str),
	}

	return expr, nil
}

func (p *parser) callonStringExpr8() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStringExpr8(stack["str"])
}

func (c *current) onStringExpr14(field any) (any, error) {
	expr := &structs.StringExpr{
		StringExprMode: structs.SEMField,
		FieldName:      field.(string),
	}

	return expr, nil
}

func (p *parser) callonStringExpr14() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStringExpr14(stack["field"])
}

func (c *current) onStringExpr26(concat any) (any, error) {
	expr := &structs.StringExpr{
		StringExprMode: structs.SEMConcatExpr,
		ConcatExpr:     concat.(*structs.ConcatExpr),
	}

	return expr, nil
}

func (p *parser) callonStringExpr26() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStringExpr26(stack["concat"])
}

func (c *current) onConcatExpr1(first, rest any) (any, error) {
	restSlice := rest.([]any)
	slice := make([]*structs.ConcatAtom, 1+len(restSlice))
	slice[0] = first.(*structs.ConcatAtom)

	for i := range restSlice {
		concatAndAtom := restSlice[i].([]any)
		slice[i+1] = concatAndAtom[1].(*structs.ConcatAtom)
	}

	expr := &structs.ConcatExpr{
		Atoms: slice,
	}

	return expr, nil
}

func (p *parser) callonConcatExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConcatExpr1(stack["first"], stack["rest"])
}

func (c *current) onConcatAtom2(text any) (any, error) {
	atom := &structs.ConcatAtom{
		IsField:  false,
		Value:    "",
		TextExpr: text.(*structs.TextExpr),
	}

	return atom, nil
}

func (p *parser) callonConcatAtom2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConcatAtom2(stack["text"])
}

func (c *current) onConcatAtom5(str any) (any, error) {
	atom := &structs.ConcatAtom{
		IsField: false,
		Value:   removeQuotes(str),
	}

	return atom, nil
}

func (p *parser) callonConcatAtom5() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConcatAtom5(stack["str"])
}

func (c *current) onConcatAtom8(number any) (any, error) {
	atom := &structs.ConcatAtom{
		IsField: false,
		Value:   number.(string),
	}

	return atom, nil
}

func (p *parser) callonConcatAtom8() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConcatAtom8(stack["number"])
}

func (c *current) onConcatAtom11(field any) (any, error) {
	atom := &structs.ConcatAtom{
		IsField: true,
		Value:   field.(string),
	}

	return atom, nil
}

func (p *parser) callonConcatAtom11() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConcatAtom11(stack["field"])
}

func (c *current) onNumericExpr1(expr any) (any, error) {
	return expr, nil
}

func (p *parser) callonNumericExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExpr1(stack["expr"])
}

func (c *current) onNumericExprLevel31(first, rest any) (any, error) {
	if rest == nil {
		return first, nil
	}

	cur := first.(*structs.NumericExpr)
	for _, v := range rest.([]any) {
		opAndClause := v.([]any)
		cur = &structs.NumericExpr{
			IsTerminal:      false,
			Op:              opAndClause[0].(string),
			Left:            cur,
			Right:           opAndClause[1].(*structs.NumericExpr),
			NumericExprMode: structs.NEMNumericExpr,
		}
	}

	return cur, nil
}

func (p *parser) callonNumericExprLevel31() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExprLevel31(stack["first"], stack["rest"])
}

func (c *current) onNumericExprLevel21(first, rest any) (any, error) {
	if rest == nil {
		return first, nil
	}

	cur := first.(*structs.NumericExpr)
	for _, v := range rest.([]any) {
		opAndClause := v.([]any)
		cur = &structs.NumericExpr{
			IsTerminal:      false,
			Op:              opAndClause[0].(string),
			Left:            cur,
			Right:           opAndClause[1].(*structs.NumericExpr),
			NumericExprMode: structs.NEMNumericExpr,
		}
	}

	return cur, nil
}

func (p *parser) callonNumericExprLevel21() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExprLevel21(stack["first"], stack["rest"])
}

func (c *current) onRoundPrecisionExpr1(expr any) (any, error) {
	rightNumericExpr, ok := expr.(*structs.NumericExpr)
	if !ok {
		return nil, fmt.Errorf("Failed to assert expr as *structs.NumericExpr")
	}

	return rightNumericExpr, nil
}

func (p *parser) callonRoundPrecisionExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRoundPrecisionExpr1(stack["expr"])
}

func (c *current) onNumericExprLevel12(expr any) (any, error) {
	return expr, nil
}

func (p *parser) callonNumericExprLevel12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExprLevel12(stack["expr"])
}

func (c *current) onNumericExprLevel18(numericEvalExpr any) (any, error) {
	return numericEvalExpr, nil
}

func (p *parser) callonNumericExprLevel18() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExprLevel18(stack["numericEvalExpr"])
}

func (c *current) onNumericExprLevel111(field any) (any, error) {
	expr := &structs.NumericExpr{
		IsTerminal:      true,
		ValueIsField:    true,
		Value:           field.(string),
		NumericExprMode: structs.NEMNumberField,
	}

	return expr, nil
}

func (p *parser) callonNumericExprLevel111() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExprLevel111(stack["field"])
}

func (c *current) onNumericExprLevel114(number any) (any, error) {
	expr := &structs.NumericExpr{
		IsTerminal:      true,
		ValueIsField:    false,
		Value:           number.(string),
		NumericExprMode: structs.NEMNumber,
	}

	return expr, nil
}

func (p *parser) callonNumericExprLevel114() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericExprLevel114(stack["number"])
}

func (c *current) onNumericEvalExpr2(opName, expr any) (any, error) {
	leftNumericExpr, ok := expr.(*structs.NumericExpr)
	if !ok {
		return nil, fmt.Errorf("Failed to assert expr as *structs.NumericExpr")
	}

	//transfer []uint8 to string
	strData, ok := opName.([]byte)
	if !ok {
		return nil, fmt.Errorf("opName is not a []byte")
	}

	opNameStr := string(strData)
	node, err := createNumericExpr(opNameStr, leftNumericExpr, nil, structs.NEMNumericExpr)
	if err != nil {
		return nil, err
	}

	return node, nil
}

func (p *parser) callonNumericEvalExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericEvalExpr2(stack["opName"], stack["expr"])
}

func (c *current) onNumericEvalExpr15(roundExpr, expr, roundPrecision any) (any, error) {
	leftNumericExpr, ok := expr.(*structs.NumericExpr)
	if !ok {
		return nil, fmt.Errorf("Failed to assert expr as *structs.NumericExpr")
	}

	var rightNumericExpr *structs.NumericExpr
	if roundPrecision != nil {
		rightNumericExpr, ok = roundPrecision.(*structs.NumericExpr)
		if !ok {
			return nil, fmt.Errorf("Failed to assert roundPrecision as *structs.NumericExpr")
		}
	}

	node, err := createNumericExpr("round", leftNumericExpr, rightNumericExpr, structs.NEMNumericExpr)
	if err != nil {
		return nil, err
	}

	return node, nil
}

func (p *parser) callonNumericEvalExpr15() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericEvalExpr15(stack["roundExpr"], stack["expr"], stack["roundPrecision"])
}

func (c *current) onNumericEvalExpr26() (any, error) {
	return &structs.NumericExpr{
		IsTerminal: true,
		Op:         "now",
	}, nil
}

func (p *parser) callonNumericEvalExpr26() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericEvalExpr26()
}

func (c *current) onNumericEvalExpr30(stringExpr, baseExpr any) (any, error) {
	stringExprConverted, ok := stringExpr.(*structs.StringExpr)
	if !ok {
		return nil, fmt.Errorf("Failed to assert stringExpr as *structs.StringExpr")
	}

	var baseExprConverted *structs.NumericExpr
	if baseExpr != nil {
		baseSlice, ok := baseExpr.([]interface{})
		if ok && len(baseSlice) > 1 {
			if base, ok := baseSlice[1].(*structs.NumericExpr); ok {
				baseExprConverted = base
			} else {
				return nil, fmt.Errorf("Failed to assert base as *structs.NumericExpr")
			}
		}
	}

	node := &structs.NumericExpr{
		IsTerminal:      false,
		Op:              "tonumber",
		Left:            nil,
		Right:           baseExprConverted,
		Val:             stringExprConverted,
		NumericExprMode: structs.NEMNumericExpr,
	}
	return node, nil
}

func (p *parser) callonNumericEvalExpr30() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericEvalExpr30(stack["stringExpr"], stack["baseExpr"])
}

func (c *current) onNumericEvalExpr42(lenExpr, expr any) (any, error) {
	return expr, nil
}

func (p *parser) callonNumericEvalExpr42() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumericEvalExpr42(stack["lenExpr"], stack["expr"])
}

func (c *current) onLenExpr2(str any) (any, error) {

	leftNumericExpr := &structs.NumericExpr{
		IsTerminal:      true,
		ValueIsField:    false,
		Value:           str.(string),
		NumericExprMode: structs.NEMLenString,
	}

	node, err := createNumericExpr("len", leftNumericExpr, nil, structs.NEMLenString)
	if err != nil {
		return nil, err
	}

	return node, nil
}

func (p *parser) callonLenExpr2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLenExpr2(stack["str"])
}

func (c *current) onLenExpr8(field any) (any, error) {

	leftNumericExpr := &structs.NumericExpr{
		IsTerminal:      true,
		ValueIsField:    true,
		Value:           field.(string),
		NumericExprMode: structs.NEMLenField,
	}

	node, err := createNumericExpr("len", leftNumericExpr, nil, structs.NEMLenField)
	if err != nil {
		return nil, err
	}

	return node, nil
}

func (p *parser) callonLenExpr8() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLenExpr8(stack["field"])
}

func (c *current) onHeadBlock2(intAsStr any) (any, error) {
	limit, err := strconv.ParseUint(intAsStr.(string), 10, 64)
	if err != nil {
		return nil, fmt.Errorf("Invalid limit (%v): %v", intAsStr.(string), err)
	}

	queryAgg := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			MaxRows: limit,
		},
	}

	return queryAgg, nil
}

func (p *parser) callonHeadBlock2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onHeadBlock2(stack["intAsStr"])
}

func (c *current) onHeadBlock12() (any, error) {
	queryAgg := &structs.QueryAggregators{
		PipeCommandType: structs.OutputTransformType,
		OutputTransforms: &structs.OutputTransforms{
			MaxRows: uint64(10), // From https://docs.splunk.com/Documentation/Splunk/9.1.0/SearchReference/Head
		},
	}

	return queryAgg, nil
}

func (p *parser) callonHeadBlock12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onHeadBlock12()
}

func (c *current) onAggregationList1(first, rest any) (any, error) {
	// Convert `rest` to a slice. Each element of the slice will be a 2-element
	// slice where the first element is ", " and the second is an Aggregator.
	restSlice := rest.([]any)

	numAggs := 1 + len(restSlice)
	aggsSlice := make([]*aggregator, numAggs)
	aggsSlice[0] = first.(*aggregator)

	for i := 1; i < numAggs; i++ {
		separatorAndAgg := restSlice[i-1].([]any)
		aggsSlice[i] = separatorAndAgg[1].(*aggregator)
	}

	return aggsSlice, nil
}

func (p *parser) callonAggregationList1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggregationList1(stack["first"], stack["rest"])
}

func (c *current) onAggregator1(aggFunc, asField any) (any, error) {
	agg := &aggregator{}
	agg.measureAgg = aggFunc.(*structs.MeasureAggregator)

	if asField != nil {
		agg.renameOutputField = true
		agg.outputFieldNewName = asField.(string)
	}

	return agg, nil
}

func (p *parser) callonAggregator1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggregator1(stack["aggFunc"], stack["asField"])
}

func (c *current) onAggFunction1(agg any) (any, error) {
	return agg, nil
}

func (p *parser) callonAggFunction1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggFunction1(stack["agg"])
}

func (c *current) onAsField1(field any) (any, error) {
	fieldStr := field.(string)

	if strings.Contains(fieldStr, "*") {
		return nil, errors.New("The field specified in `AS` cannot contain wildcards")
	}

	if fieldStr[0] == '"' && fieldStr[len(fieldStr)-1] == '"' {
		fieldStr = fieldStr[1 : len(fieldStr)-1]
	}

	return fieldStr, nil
}

func (p *parser) callonAsField1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAsField1(stack["field"])
}

func (c *current) onAggCount2(boolExpr any) (any, error) {
	valueExpr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolExpr.(*structs.BoolExpr),
	}

	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Count,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr,
	}

	return agg, nil
}

func (p *parser) callonAggCount2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggCount2(stack["boolExpr"])
}

func (c *current) onAggCount12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Count,
	}

	return agg, nil
}

func (p *parser) callonAggCount12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggCount12(stack["field"])
}

func (c *current) onAggCount21() (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  "*",
		MeasureFunc: utils.Count,
	}

	return agg, nil
}

func (p *parser) callonAggCount21() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggCount21()
}

func (c *current) onAggDistinctCount2(valueExpr any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Cardinality,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr.(*structs.ValueExpr),
	}

	return agg, nil
}

func (p *parser) callonAggDistinctCount2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggDistinctCount2(stack["valueExpr"])
}

func (c *current) onAggDistinctCount12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Cardinality,
	}

	return agg, nil
}

func (p *parser) callonAggDistinctCount12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggDistinctCount12(stack["field"])
}

func (c *current) onAggAvg2(boolComparisonExpr any) (any, error) {
	valueExpr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolComparisonExpr.(*structs.BoolExpr),
	}

	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Avg,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr,
	}

	return agg, nil
}

func (p *parser) callonAggAvg2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggAvg2(stack["boolComparisonExpr"])
}

func (c *current) onAggAvg12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Avg,
	}

	return agg, nil
}

func (p *parser) callonAggAvg12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggAvg12(stack["field"])
}

func (c *current) onAggMin2(boolComparisonExpr any) (any, error) {
	valueExpr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolComparisonExpr.(*structs.BoolExpr),
	}

	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Min,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr,
	}

	return agg, nil
}

func (p *parser) callonAggMin2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggMin2(stack["boolComparisonExpr"])
}

func (c *current) onAggMin12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Min,
	}

	return agg, nil
}

func (p *parser) callonAggMin12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggMin12(stack["field"])
}

func (c *current) onAggMax2(boolComparisonExpr any) (any, error) {
	valueExpr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolComparisonExpr.(*structs.BoolExpr),
	}

	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Max,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr,
	}

	return agg, nil
}

func (p *parser) callonAggMax2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggMax2(stack["boolComparisonExpr"])
}

func (c *current) onAggMax12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Max,
	}

	return agg, nil
}

func (p *parser) callonAggMax12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggMax12(stack["field"])
}

func (c *current) onAggRange2(boolComparisonExpr any) (any, error) {
	valueExpr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolComparisonExpr.(*structs.BoolExpr),
	}

	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Range,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr,
	}

	return agg, nil
}

func (p *parser) callonAggRange2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggRange2(stack["boolComparisonExpr"])
}

func (c *current) onAggRange12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Range,
	}

	return agg, nil
}

func (p *parser) callonAggRange12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggRange12(stack["field"])
}

func (c *current) onAggSum2(boolComparisonExpr any) (any, error) {
	valueExpr := &structs.ValueExpr{
		ValueExprMode: structs.VEMBooleanExpr,
		BooleanExpr:   boolComparisonExpr.(*structs.BoolExpr),
	}

	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Sum,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr,
	}

	return agg, nil
}

func (p *parser) callonAggSum2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggSum2(stack["boolComparisonExpr"])
}

func (c *current) onAggSum12(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Sum,
	}

	return agg, nil
}

func (p *parser) callonAggSum12() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggSum12(stack["field"])
}

func (c *current) onAggValues2(valueExpr any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:      "",
		MeasureFunc:     utils.Values,
		StrEnc:          string(c.text),
		ValueColRequest: valueExpr.(*structs.ValueExpr),
	}

	return agg, nil
}

func (p *parser) callonAggValues2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggValues2(stack["valueExpr"])
}

func (c *current) onAggValues10(field any) (any, error) {
	agg := &structs.MeasureAggregator{
		MeasureCol:  field.(string),
		MeasureFunc: utils.Values,
	}

	return agg, nil
}

func (p *parser) callonAggValues10() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onAggValues10(stack["field"])
}

func (c *current) onFieldWithNumberValue1(keyValuePair any) (any, error) {
	return keyValuePair, nil
}

func (p *parser) callonFieldWithNumberValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldWithNumberValue1(stack["keyValuePair"])
}

func (c *current) onNamedFieldWithNumberValue1(key, op, value any) (any, error) {
	node := &ast.Node{
		NodeType: ast.NodeTerminal,
		Comparison: ast.Comparison{
			Op:     op.(string),
			Field:  key.(string),
			Values: value,
		},
	}

	return node, nil
}

func (p *parser) callonNamedFieldWithNumberValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNamedFieldWithNumberValue1(stack["key"], stack["op"], stack["value"])
}

func (c *current) onUnnamedFieldWithNumberValue1(value any) (any, error) {
	node := &ast.Node{
		NodeType: ast.NodeTerminal,
		Comparison: ast.Comparison{
			Op:     "=",
			Field:  "*",
			Values: value,
		},
	}

	return node, nil
}

func (p *parser) callonUnnamedFieldWithNumberValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onUnnamedFieldWithNumberValue1(stack["value"])
}

func (c *current) onFieldWithBooleanValue1(key, op, value any) (any, error) {
	node := &ast.Node{
		NodeType: ast.NodeTerminal,
		Comparison: ast.Comparison{
			Op:     op.(string),
			Field:  key.(string),
			Values: value,
		},
	}

	return node, nil
}

func (p *parser) callonFieldWithBooleanValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldWithBooleanValue1(stack["key"], stack["op"], stack["value"])
}

func (c *current) onFieldWithStringValue1(keyValuePair any) (any, error) {
	return keyValuePair, nil
}

func (p *parser) callonFieldWithStringValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldWithStringValue1(stack["keyValuePair"])
}

func (c *current) onNamedFieldWithStringValue1(key, op, value any) (any, error) {
	node := &ast.Node{
		NodeType: ast.NodeTerminal,
		Comparison: ast.Comparison{
			Op:     op.(string),
			Field:  key.(string),
			Values: value,
		},
	}
	return node, nil
}

func (p *parser) callonNamedFieldWithStringValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNamedFieldWithStringValue1(stack["key"], stack["op"], stack["value"])
}

func (c *current) onUnnamedFieldWithStringValue1(value any) (any, error) {
	node := &ast.Node{
		NodeType: ast.NodeTerminal,
		Comparison: ast.Comparison{
			Op:     "=",
			Field:  "*",
			Values: value,
		},
	}
	return node, nil
}

func (p *parser) callonUnnamedFieldWithStringValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onUnnamedFieldWithStringValue1(stack["value"])
}

func (c *current) onFieldNameList1(first, rest any) (any, error) {
	// Convert `rest` to a slice. Each element of the slice will be a 2-element
	// slice where the first element is ", " and the second is a FieldName.
	restSlice := rest.([]any)

	numFieldNames := 1 + len(restSlice)
	fields := make([]string, numFieldNames)
	fields[0] = first.(string)

	for i := 1; i < numFieldNames; i++ {
		separatorAndField := restSlice[i-1].([]any)
		fields[i] = separatorAndField[1].(string)
	}

	return fields, nil
}

func (p *parser) callonFieldNameList1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldNameList1(stack["first"], stack["rest"])
}

func (c *current) onFieldName1() (any, error) {
	return string(c.text), nil
}

func (p *parser) callonFieldName1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldName1()
}

func (c *current) onString1(str any) (any, error) {
	return str, nil
}

func (p *parser) callonString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onString1(stack["str"])
}

func (c *current) onQuotedString1() (any, error) {
	// The returned string has quotes as the first and last character.
	return string(c.text), nil
}

func (p *parser) callonQuotedString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onQuotedString1()
}

func (c *current) onBoolean1() (any, error) {
	boolValue, _ := strconv.ParseBool(string(c.text))
	return boolValue, nil
}

func (p *parser) callonBoolean1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBoolean1()
}

func (c *current) onUnquotedString1() (any, error) {
	// Return the string wrapped in quotes.
	str := "\"" + string(c.text) + "\""
	return str, nil
}

func (p *parser) callonUnquotedString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onUnquotedString1()
}

func (c *current) onRenamePattern1() (any, error) {
	return string(c.text), nil
}

func (p *parser) callonRenamePattern1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onRenamePattern1()
}

func (c *current) onNumber1(number any) (any, error) {
	return json.Number(number.(string)), nil
}

func (p *parser) callonNumber1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumber1(stack["number"])
}

func (c *current) onNumberAsString1(number any) (any, error) {
	return number, nil
}

func (p *parser) callonNumberAsString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNumberAsString1(stack["number"])
}

func (c *current) onFloatAsString1() (any, error) {
	return string(c.text), nil
}

func (p *parser) callonFloatAsString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFloatAsString1()
}

func (c *current) onIntegerAsString1() (any, error) {
	return string(c.text), nil
}

func (p *parser) callonIntegerAsString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onIntegerAsString1()
}

func (c *current) onEqualityOperator1(op any) (any, error) {
	opStr, err := transferUint8ToString(op)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: EqualityOperator: %v", err)
	}
	return opStr, nil
}

func (p *parser) callonEqualityOperator1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEqualityOperator1(stack["op"])
}

func (c *current) onInequalityOperator1(op any) (any, error) {
	opStr, err := transferUint8ToString(op)
	if err != nil {
		return nil, fmt.Errorf("Spl peg: InequalityOperator: %v", err)
	}
	return opStr, nil
}

func (p *parser) callonInequalityOperator1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onInequalityOperator1(stack["op"])
}

func (c *current) onEqualityOrInequality2(op any) (any, error) {
	return op, nil
}

func (p *parser) callonEqualityOrInequality2() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEqualityOrInequality2(stack["op"])
}

func (c *current) onEqualityOrInequality5(op any) (any, error) {
	return op, nil
}

func (p *parser) callonEqualityOrInequality5() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEqualityOrInequality5(stack["op"])
}

func (c *current) onOpPlus1() (any, error) {
	return "+", nil
}

func (p *parser) callonOpPlus1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onOpPlus1()
}

func (c *current) onOpMinus1() (any, error) {
	return "-", nil
}

func (p *parser) callonOpMinus1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onOpMinus1()
}

func (c *current) onOpMul1() (any, error) {
	return "*", nil
}

func (p *parser) callonOpMul1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onOpMul1()
}

func (c *current) onOpDiv1() (any, error) {
	return "/", nil
}

func (p *parser) callonOpDiv1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onOpDiv1()
}

func (c *current) onSecond1() (any, error) {
	return utils.TMSecond, nil
}

func (p *parser) callonSecond1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSecond1()
}

func (c *current) onMinute1() (any, error) {
	return utils.TMMinute, nil
}

func (p *parser) callonMinute1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onMinute1()
}

func (c *current) onHour1() (any, error) {
	return utils.TMHour, nil
}

func (p *parser) callonHour1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onHour1()
}

func (c *current) onDay1() (any, error) {
	return utils.TMDay, nil
}

func (p *parser) callonDay1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDay1()
}

func (c *current) onWeek1() (any, error) {
	return utils.TMWeek, nil
}

func (p *parser) callonWeek1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onWeek1()
}

func (c *current) onMonth1() (any, error) {
	return utils.TMMonth, nil
}

func (p *parser) callonMonth1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onMonth1()
}

func (c *current) onQuarter1() (any, error) {
	return utils.TMQuarter, nil
}

func (p *parser) callonQuarter1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onQuarter1()
}

func (c *current) onSubseconds1() (any, error) {
	timeUnit, err := utils.ConvertSubseconds(string(c.text))
	if err != nil {
		return nil, fmt.Errorf("Spl peg: Subseconds: %v", err)
	}
	return timeUnit, nil
}

func (p *parser) callonSubseconds1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSubseconds1()
}

func (c *current) onTransactionBlock1(txnOptions any) (any, error) {
	queryAgg := &structs.QueryAggregators{
		PipeCommandType:      structs.TransactionType,
		TransactionArguments: txnOptions.(*structs.TransactionArguments),
	}
	return queryAgg, nil
}

func (p *parser) callonTransactionBlock1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionBlock1(stack["txnOptions"])
}

func (c *current) onTransactionOptions1(txnOptions any) (any, error) {

	transactionRequest := &structs.TransactionArguments{}

	if txnOptions != nil {
		txnArgs := txnOptions.(*TxnArgs).arguments
		transactionRequest.Fields = txnArgs.Fields
		transactionRequest.StartsWith = txnArgs.StartsWith
		transactionRequest.EndsWith = txnArgs.EndsWith
	}

	return transactionRequest, nil
}

func (p *parser) callonTransactionOptions1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionOptions1(stack["txnOptions"])
}

func (c *current) onTransactionDefinitionOptionsList1(first, rest any) (any, error) {

	restSlice := rest.([]any)
	txnArgs := &TxnArgs{
		argOption: "txn-definition",
		arguments: &structs.TransactionArguments{},
	}

	numArgs := 1 + len(restSlice)

	for i := 0; i < numArgs; i++ {
		var txnArg *TxnArgs
		if i == 0 {
			txnArg = first.(*TxnArgs)
		} else {
			separatorAndArg := restSlice[i-1].([]any)
			txnArg = separatorAndArg[1].(*TxnArgs)
		}
		argOption := txnArg.argOption

		switch argOption {
		case "fields":
			txnArgs.arguments.Fields = txnArg.arguments.Fields
		case "startswith":
			txnArgs.arguments.StartsWith = txnArg.arguments.StartsWith
		case "endswith":
			txnArgs.arguments.EndsWith = txnArg.arguments.EndsWith
		default:
			return nil, fmt.Errorf("Not a Valid Transaction Argument option")
		}
	}

	return txnArgs, nil
}

func (p *parser) callonTransactionDefinitionOptionsList1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionDefinitionOptionsList1(stack["first"], stack["rest"])
}

func (c *current) onTransactionDefinitionOption1(option any) (any, error) {
	return option, nil
}

func (p *parser) callonTransactionDefinitionOption1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionDefinitionOption1(stack["option"])
}

func (c *current) onSpaceSeparatedFieldNameList1(first, rest any) (any, error) {
	var fields []string
	fields = append(fields, first.(string))
	for _, r := range rest.([]any) {
		// Extracting the field name from the tuple (SPACE, FieldName)
		fields = append(fields, r.([]any)[1].(string))
	}

	txnArg := &TxnArgs{
		argOption: "fields",
		arguments: &structs.TransactionArguments{
			Fields: fields,
		},
	}

	return txnArg, nil
}

func (p *parser) callonSpaceSeparatedFieldNameList1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSpaceSeparatedFieldNameList1(stack["first"], stack["rest"])
}

func (c *current) onStartsWithOption1(strExpr any) (any, error) {
	txnArg := &TxnArgs{
		argOption: "startswith",
		arguments: &structs.TransactionArguments{
			StartsWith: strExpr.(*structs.FilterStringExpr),
		},
	}
	return txnArg, nil
}

func (p *parser) callonStartsWithOption1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStartsWithOption1(stack["strExpr"])
}

func (c *current) onEndsWithOption1(strExpr any) (any, error) {
	txnArg := &TxnArgs{
		argOption: "endswith",
		arguments: &structs.TransactionArguments{
			EndsWith: strExpr.(*structs.FilterStringExpr),
		},
	}
	return txnArg, nil
}

func (p *parser) callonEndsWithOption1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEndsWithOption1(stack["strExpr"])
}

func (c *current) onTransactionFilterString1(strExpr any) (any, error) {
	return strExpr, nil
}

func (p *parser) callonTransactionFilterString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionFilterString1(stack["strExpr"])
}

func (c *current) onTransactionQuotedString1(str any) (any, error) {
	return str, nil
}

func (p *parser) callonTransactionQuotedString1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionQuotedString1(stack["str"])
}

func (c *current) onTransactionQuotedStringSearchExpr1(searchClause any) (any, error) {
	filterStrExpr := &structs.FilterStringExpr{
		SearchNode: searchClause.(*ast.Node),
	}

	return filterStrExpr, nil
}

func (p *parser) callonTransactionQuotedStringSearchExpr1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionQuotedStringSearchExpr1(stack["searchClause"])
}

func (c *current) onQuotedStringNoOp1() (any, error) {
	// The returned string has quotes as the first and last character.
	return string(c.text), nil
}

func (p *parser) callonQuotedStringNoOp1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onQuotedStringNoOp1()
}

func (c *current) onTransactionQuotedStringValue1(str any) (any, error) {
	filterStrExpr := &structs.FilterStringExpr{
		StringValue: removeQuotes(str.(string)),
	}

	return filterStrExpr, nil
}

func (p *parser) callonTransactionQuotedStringValue1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionQuotedStringValue1(stack["str"])
}

func (c *current) onTransactionSearch1(expr any) (any, error) {

	filterStrExpr := &structs.FilterStringExpr{
		SearchNode: expr.(*ast.Node),
	}

	return filterStrExpr, nil
}

func (p *parser) callonTransactionSearch1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionSearch1(stack["expr"])
}

func (c *current) onTransactionEval1(condition any) (any, error) {
	filterStrExpr := &structs.FilterStringExpr{
		EvalBoolExpr: condition.(*structs.BoolExpr),
	}

	return filterStrExpr, nil
}

func (p *parser) callonTransactionEval1() (any, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTransactionEval1(stack["condition"])
}

var (
	// errNoRule is returned when the grammar to parse has no rule.
	errNoRule = errors.New("grammar has no rule")

	// errInvalidEntrypoint is returned when the specified entrypoint rule
	// does not exit.
	errInvalidEntrypoint = errors.New("invalid entrypoint")

	// errInvalidEncoding is returned when the source is not properly
	// utf8-encoded.
	errInvalidEncoding = errors.New("invalid encoding")

	// errMaxExprCnt is used to signal that the maximum number of
	// expressions have been parsed.
	errMaxExprCnt = errors.New("max number of expresssions parsed")
)

// Option is a function that can set an option on the parser. It returns
// the previous setting as an Option.
type Option func(*parser) Option

// MaxExpressions creates an Option to stop parsing after the provided
// number of expressions have been parsed, if the value is 0 then the parser will
// parse for as many steps as needed (possibly an infinite number).
//
// The default for maxExprCnt is 0.
func MaxExpressions(maxExprCnt uint64) Option {
	return func(p *parser) Option {
		oldMaxExprCnt := p.maxExprCnt
		p.maxExprCnt = maxExprCnt
		return MaxExpressions(oldMaxExprCnt)
	}
}

// Entrypoint creates an Option to set the rule name to use as entrypoint.
// The rule name must have been specified in the -alternate-entrypoints
// if generating the parser with the -optimize-grammar flag, otherwise
// it may have been optimized out. Passing an empty string sets the
// entrypoint to the first rule in the grammar.
//
// The default is to start parsing at the first rule in the grammar.
func Entrypoint(ruleName string) Option {
	return func(p *parser) Option {
		oldEntrypoint := p.entrypoint
		p.entrypoint = ruleName
		if ruleName == "" {
			p.entrypoint = g.rules[0].name
		}
		return Entrypoint(oldEntrypoint)
	}
}

// Statistics adds a user provided Stats struct to the parser to allow
// the user to process the results after the parsing has finished.
// Also the key for the "no match" counter is set.
//
// Example usage:
//
//	input := "input"
//	stats := Stats{}
//	_, err := Parse("input-file", []byte(input), Statistics(&stats, "no match"))
//	if err != nil {
//	    log.Panicln(err)
//	}
//	b, err := json.MarshalIndent(stats.ChoiceAltCnt, "", "  ")
//	if err != nil {
//	    log.Panicln(err)
//	}
//	fmt.Println(string(b))
func Statistics(stats *Stats, choiceNoMatch string) Option {
	return func(p *parser) Option {
		oldStats := p.Stats
		p.Stats = stats
		oldChoiceNoMatch := p.choiceNoMatch
		p.choiceNoMatch = choiceNoMatch
		if p.Stats.ChoiceAltCnt == nil {
			p.Stats.ChoiceAltCnt = make(map[string]map[string]int)
		}
		return Statistics(oldStats, oldChoiceNoMatch)
	}
}

// Debug creates an Option to set the debug flag to b. When set to true,
// debugging information is printed to stdout while parsing.
//
// The default is false.
func Debug(b bool) Option {
	return func(p *parser) Option {
		old := p.debug
		p.debug = b
		return Debug(old)
	}
}

// Memoize creates an Option to set the memoize flag to b. When set to true,
// the parser will cache all results so each expression is evaluated only
// once. This guarantees linear parsing time even for pathological cases,
// at the expense of more memory and slower times for typical cases.
//
// The default is false.
func Memoize(b bool) Option {
	return func(p *parser) Option {
		old := p.memoize
		p.memoize = b
		return Memoize(old)
	}
}

// AllowInvalidUTF8 creates an Option to allow invalid UTF-8 bytes.
// Every invalid UTF-8 byte is treated as a utf8.RuneError (U+FFFD)
// by character class matchers and is matched by the any matcher.
// The returned matched value, c.text and c.offset are NOT affected.
//
// The default is false.
func AllowInvalidUTF8(b bool) Option {
	return func(p *parser) Option {
		old := p.allowInvalidUTF8
		p.allowInvalidUTF8 = b
		return AllowInvalidUTF8(old)
	}
}

// Recover creates an Option to set the recover flag to b. When set to
// true, this causes the parser to recover from panics and convert it
// to an error. Setting it to false can be useful while debugging to
// access the full stack trace.
//
// The default is true.
func Recover(b bool) Option {
	return func(p *parser) Option {
		old := p.recover
		p.recover = b
		return Recover(old)
	}
}

// GlobalStore creates an Option to set a key to a certain value in
// the globalStore.
func GlobalStore(key string, value any) Option {
	return func(p *parser) Option {
		old := p.cur.globalStore[key]
		p.cur.globalStore[key] = value
		return GlobalStore(key, old)
	}
}

// InitState creates an Option to set a key to a certain value in
// the global "state" store.
func InitState(key string, value any) Option {
	return func(p *parser) Option {
		old := p.cur.state[key]
		p.cur.state[key] = value
		return InitState(key, old)
	}
}

// ParseFile parses the file identified by filename.
func ParseFile(filename string, opts ...Option) (i any, err error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer func() {
		if closeErr := f.Close(); closeErr != nil {
			err = closeErr
		}
	}()
	return ParseReader(filename, f, opts...)
}

// ParseReader parses the data from r using filename as information in the
// error messages.
func ParseReader(filename string, r io.Reader, opts ...Option) (any, error) {
	b, err := io.ReadAll(r)
	if err != nil {
		return nil, err
	}

	return Parse(filename, b, opts...)
}

// Parse parses the data from b using filename as information in the
// error messages.
func Parse(filename string, b []byte, opts ...Option) (any, error) {
	return newParser(filename, b, opts...).parse(g)
}

// position records a position in the text.
type position struct {
	line, col, offset int
}

func (p position) String() string {
	return strconv.Itoa(p.line) + ":" + strconv.Itoa(p.col) + " [" + strconv.Itoa(p.offset) + "]"
}

// savepoint stores all state required to go back to this point in the
// parser.
type savepoint struct {
	position
	rn rune
	w  int
}

type current struct {
	pos  position // start position of the match
	text []byte   // raw text of the match

	// state is a store for arbitrary key,value pairs that the user wants to be
	// tied to the backtracking of the parser.
	// This is always rolled back if a parsing rule fails.
	state storeDict

	// globalStore is a general store for the user to store arbitrary key-value
	// pairs that they need to manage and that they do not want tied to the
	// backtracking of the parser. This is only modified by the user and never
	// rolled back by the parser. It is always up to the user to keep this in a
	// consistent state.
	globalStore storeDict
}

type storeDict map[string]any

// the AST types...

type grammar struct {
	pos   position
	rules []*rule
}

type rule struct {
	pos         position
	name        string
	displayName string
	expr        any
}

type choiceExpr struct {
	pos          position
	alternatives []any
}

type actionExpr struct {
	pos  position
	expr any
	run  func(*parser) (any, error)
}

type recoveryExpr struct {
	pos          position
	expr         any
	recoverExpr  any
	failureLabel []string
}

type seqExpr struct {
	pos   position
	exprs []any
}

type throwExpr struct {
	pos   position
	label string
}

type labeledExpr struct {
	pos   position
	label string
	expr  any
}

type expr struct {
	pos  position
	expr any
}

type (
	andExpr        expr
	notExpr        expr
	zeroOrOneExpr  expr
	zeroOrMoreExpr expr
	oneOrMoreExpr  expr
)

type ruleRefExpr struct {
	pos  position
	name string
}

type stateCodeExpr struct {
	pos position
	run func(*parser) error
}

type andCodeExpr struct {
	pos position
	run func(*parser) (bool, error)
}

type notCodeExpr struct {
	pos position
	run func(*parser) (bool, error)
}

type litMatcher struct {
	pos        position
	val        string
	ignoreCase bool
	want       string
}

type charClassMatcher struct {
	pos             position
	val             string
	basicLatinChars [128]bool
	chars           []rune
	ranges          []rune
	classes         []*unicode.RangeTable
	ignoreCase      bool
	inverted        bool
}

type anyMatcher position

// errList cumulates the errors found by the parser.
type errList []error

func (e *errList) add(err error) {
	*e = append(*e, err)
}

func (e errList) err() error {
	if len(e) == 0 {
		return nil
	}
	e.dedupe()
	return e
}

func (e *errList) dedupe() {
	var cleaned []error
	set := make(map[string]bool)
	for _, err := range *e {
		if msg := err.Error(); !set[msg] {
			set[msg] = true
			cleaned = append(cleaned, err)
		}
	}
	*e = cleaned
}

func (e errList) Error() string {
	switch len(e) {
	case 0:
		return ""
	case 1:
		return e[0].Error()
	default:
		var buf bytes.Buffer

		for i, err := range e {
			if i > 0 {
				buf.WriteRune('\n')
			}
			buf.WriteString(err.Error())
		}
		return buf.String()
	}
}

// parserError wraps an error with a prefix indicating the rule in which
// the error occurred. The original error is stored in the Inner field.
type parserError struct {
	Inner    error
	pos      position
	prefix   string
	expected []string
}

// Error returns the error message.
func (p *parserError) Error() string {
	return p.prefix + ": " + p.Inner.Error()
}

// newParser creates a parser with the specified input source and options.
func newParser(filename string, b []byte, opts ...Option) *parser {
	stats := Stats{
		ChoiceAltCnt: make(map[string]map[string]int),
	}

	p := &parser{
		filename: filename,
		errs:     new(errList),
		data:     b,
		pt:       savepoint{position: position{line: 1}},
		recover:  true,
		cur: current{
			state:       make(storeDict),
			globalStore: make(storeDict),
		},
		maxFailPos:      position{col: 1, line: 1},
		maxFailExpected: make([]string, 0, 20),
		Stats:           &stats,
		// start rule is rule [0] unless an alternate entrypoint is specified
		entrypoint: g.rules[0].name,
	}
	p.setOptions(opts)

	if p.maxExprCnt == 0 {
		p.maxExprCnt = math.MaxUint64
	}

	return p
}

// setOptions applies the options to the parser.
func (p *parser) setOptions(opts []Option) {
	for _, opt := range opts {
		opt(p)
	}
}

type resultTuple struct {
	v   any
	b   bool
	end savepoint
}

const choiceNoMatch = -1

// Stats stores some statistics, gathered during parsing
type Stats struct {
	// ExprCnt counts the number of expressions processed during parsing
	// This value is compared to the maximum number of expressions allowed
	// (set by the MaxExpressions option).
	ExprCnt uint64

	// ChoiceAltCnt is used to count for each ordered choice expression,
	// which alternative is used how may times.
	// These numbers allow to optimize the order of the ordered choice expression
	// to increase the performance of the parser
	//
	// The outer key of ChoiceAltCnt is composed of the name of the rule as well
	// as the line and the column of the ordered choice.
	// The inner key of ChoiceAltCnt is the number (one-based) of the matching alternative.
	// For each alternative the number of matches are counted. If an ordered choice does not
	// match, a special counter is incremented. The name of this counter is set with
	// the parser option Statistics.
	// For an alternative to be included in ChoiceAltCnt, it has to match at least once.
	ChoiceAltCnt map[string]map[string]int
}

type parser struct {
	filename string
	pt       savepoint
	cur      current

	data []byte
	errs *errList

	depth   int
	recover bool
	debug   bool

	memoize bool
	// memoization table for the packrat algorithm:
	// map[offset in source] map[expression or rule] {value, match}
	memo map[int]map[any]resultTuple

	// rules table, maps the rule identifier to the rule node
	rules map[string]*rule
	// variables stack, map of label to value
	vstack []map[string]any
	// rule stack, allows identification of the current rule in errors
	rstack []*rule

	// parse fail
	maxFailPos            position
	maxFailExpected       []string
	maxFailInvertExpected bool

	// max number of expressions to be parsed
	maxExprCnt uint64
	// entrypoint for the parser
	entrypoint string

	allowInvalidUTF8 bool

	*Stats

	choiceNoMatch string
	// recovery expression stack, keeps track of the currently available recovery expression, these are traversed in reverse
	recoveryStack []map[string]any
}

// push a variable set on the vstack.
func (p *parser) pushV() {
	if cap(p.vstack) == len(p.vstack) {
		// create new empty slot in the stack
		p.vstack = append(p.vstack, nil)
	} else {
		// slice to 1 more
		p.vstack = p.vstack[:len(p.vstack)+1]
	}

	// get the last args set
	m := p.vstack[len(p.vstack)-1]
	if m != nil && len(m) == 0 {
		// empty map, all good
		return
	}

	m = make(map[string]any)
	p.vstack[len(p.vstack)-1] = m
}

// pop a variable set from the vstack.
func (p *parser) popV() {
	// if the map is not empty, clear it
	m := p.vstack[len(p.vstack)-1]
	if len(m) > 0 {
		// GC that map
		p.vstack[len(p.vstack)-1] = nil
	}
	p.vstack = p.vstack[:len(p.vstack)-1]
}

// push a recovery expression with its labels to the recoveryStack
func (p *parser) pushRecovery(labels []string, expr any) {
	if cap(p.recoveryStack) == len(p.recoveryStack) {
		// create new empty slot in the stack
		p.recoveryStack = append(p.recoveryStack, nil)
	} else {
		// slice to 1 more
		p.recoveryStack = p.recoveryStack[:len(p.recoveryStack)+1]
	}

	m := make(map[string]any, len(labels))
	for _, fl := range labels {
		m[fl] = expr
	}
	p.recoveryStack[len(p.recoveryStack)-1] = m
}

// pop a recovery expression from the recoveryStack
func (p *parser) popRecovery() {
	// GC that map
	p.recoveryStack[len(p.recoveryStack)-1] = nil

	p.recoveryStack = p.recoveryStack[:len(p.recoveryStack)-1]
}

func (p *parser) print(prefix, s string) string {
	if !p.debug {
		return s
	}

	fmt.Printf("%s %d:%d:%d: %s [%#U]\n",
		prefix, p.pt.line, p.pt.col, p.pt.offset, s, p.pt.rn)
	return s
}

func (p *parser) printIndent(mark string, s string) string {
	return p.print(strings.Repeat(" ", p.depth)+mark, s)
}

func (p *parser) in(s string) string {
	res := p.printIndent(">", s)
	p.depth++
	return res
}

func (p *parser) out(s string) string {
	p.depth--
	return p.printIndent("<", s)
}

func (p *parser) addErr(err error) {
	p.addErrAt(err, p.pt.position, []string{})
}

func (p *parser) addErrAt(err error, pos position, expected []string) {
	var buf bytes.Buffer
	if p.filename != "" {
		buf.WriteString(p.filename)
	}
	if buf.Len() > 0 {
		buf.WriteString(":")
	}
	buf.WriteString(fmt.Sprintf("%d:%d (%d)", pos.line, pos.col, pos.offset))
	if len(p.rstack) > 0 {
		if buf.Len() > 0 {
			buf.WriteString(": ")
		}
		rule := p.rstack[len(p.rstack)-1]
		if rule.displayName != "" {
			buf.WriteString("rule " + rule.displayName)
		} else {
			buf.WriteString("rule " + rule.name)
		}
	}
	pe := &parserError{Inner: err, pos: pos, prefix: buf.String(), expected: expected}
	p.errs.add(pe)
}

func (p *parser) failAt(fail bool, pos position, want string) {
	// process fail if parsing fails and not inverted or parsing succeeds and invert is set
	if fail == p.maxFailInvertExpected {
		if pos.offset < p.maxFailPos.offset {
			return
		}

		if pos.offset > p.maxFailPos.offset {
			p.maxFailPos = pos
			p.maxFailExpected = p.maxFailExpected[:0]
		}

		if p.maxFailInvertExpected {
			want = "!" + want
		}
		p.maxFailExpected = append(p.maxFailExpected, want)
	}
}

// read advances the parser to the next rune.
func (p *parser) read() {
	p.pt.offset += p.pt.w
	rn, n := utf8.DecodeRune(p.data[p.pt.offset:])
	p.pt.rn = rn
	p.pt.w = n
	p.pt.col++
	if rn == '\n' {
		p.pt.line++
		p.pt.col = 0
	}

	if rn == utf8.RuneError && n == 1 { // see utf8.DecodeRune
		if !p.allowInvalidUTF8 {
			p.addErr(errInvalidEncoding)
		}
	}
}

// restore parser position to the savepoint pt.
func (p *parser) restore(pt savepoint) {
	if p.debug {
		defer p.out(p.in("restore"))
	}
	if pt.offset == p.pt.offset {
		return
	}
	p.pt = pt
}

// Cloner is implemented by any value that has a Clone method, which returns a
// copy of the value. This is mainly used for types which are not passed by
// value (e.g map, slice, chan) or structs that contain such types.
//
// This is used in conjunction with the global state feature to create proper
// copies of the state to allow the parser to properly restore the state in
// the case of backtracking.
type Cloner interface {
	Clone() any
}

var statePool = &sync.Pool{
	New: func() any { return make(storeDict) },
}

func (sd storeDict) Discard() {
	for k := range sd {
		delete(sd, k)
	}
	statePool.Put(sd)
}

// clone and return parser current state.
func (p *parser) cloneState() storeDict {
	if p.debug {
		defer p.out(p.in("cloneState"))
	}

	state := statePool.Get().(storeDict)
	for k, v := range p.cur.state {
		if c, ok := v.(Cloner); ok {
			state[k] = c.Clone()
		} else {
			state[k] = v
		}
	}
	return state
}

// restore parser current state to the state storeDict.
// every restoreState should applied only one time for every cloned state
func (p *parser) restoreState(state storeDict) {
	if p.debug {
		defer p.out(p.in("restoreState"))
	}
	p.cur.state.Discard()
	p.cur.state = state
}

// get the slice of bytes from the savepoint start to the current position.
func (p *parser) sliceFrom(start savepoint) []byte {
	return p.data[start.position.offset:p.pt.position.offset]
}

func (p *parser) getMemoized(node any) (resultTuple, bool) {
	if len(p.memo) == 0 {
		return resultTuple{}, false
	}
	m := p.memo[p.pt.offset]
	if len(m) == 0 {
		return resultTuple{}, false
	}
	res, ok := m[node]
	return res, ok
}

func (p *parser) setMemoized(pt savepoint, node any, tuple resultTuple) {
	if p.memo == nil {
		p.memo = make(map[int]map[any]resultTuple)
	}
	m := p.memo[pt.offset]
	if m == nil {
		m = make(map[any]resultTuple)
		p.memo[pt.offset] = m
	}
	m[node] = tuple
}

func (p *parser) buildRulesTable(g *grammar) {
	p.rules = make(map[string]*rule, len(g.rules))
	for _, r := range g.rules {
		p.rules[r.name] = r
	}
}

func (p *parser) parse(g *grammar) (val any, err error) {
	if len(g.rules) == 0 {
		p.addErr(errNoRule)
		return nil, p.errs.err()
	}

	// TODO : not super critical but this could be generated
	p.buildRulesTable(g)

	if p.recover {
		// panic can be used in action code to stop parsing immediately
		// and return the panic as an error.
		defer func() {
			if e := recover(); e != nil {
				if p.debug {
					defer p.out(p.in("panic handler"))
				}
				val = nil
				switch e := e.(type) {
				case error:
					p.addErr(e)
				default:
					p.addErr(fmt.Errorf("%v", e))
				}
				err = p.errs.err()
			}
		}()
	}

	startRule, ok := p.rules[p.entrypoint]
	if !ok {
		p.addErr(errInvalidEntrypoint)
		return nil, p.errs.err()
	}

	p.read() // advance to first rune
	val, ok = p.parseRuleWrap(startRule)
	if !ok {
		if len(*p.errs) == 0 {
			// If parsing fails, but no errors have been recorded, the expected values
			// for the farthest parser position are returned as error.
			maxFailExpectedMap := make(map[string]struct{}, len(p.maxFailExpected))
			for _, v := range p.maxFailExpected {
				maxFailExpectedMap[v] = struct{}{}
			}
			expected := make([]string, 0, len(maxFailExpectedMap))
			eof := false
			if _, ok := maxFailExpectedMap["!."]; ok {
				delete(maxFailExpectedMap, "!.")
				eof = true
			}
			for k := range maxFailExpectedMap {
				expected = append(expected, k)
			}
			sort.Strings(expected)
			if eof {
				expected = append(expected, "EOF")
			}
			p.addErrAt(errors.New("no match found, expected: "+listJoin(expected, ", ", "or")), p.maxFailPos, expected)
		}

		return nil, p.errs.err()
	}
	return val, p.errs.err()
}

func listJoin(list []string, sep string, lastSep string) string {
	switch len(list) {
	case 0:
		return ""
	case 1:
		return list[0]
	default:
		return strings.Join(list[:len(list)-1], sep) + " " + lastSep + " " + list[len(list)-1]
	}
}

func (p *parser) parseRuleMemoize(rule *rule) (any, bool) {
	res, ok := p.getMemoized(rule)
	if ok {
		p.restore(res.end)
		return res.v, res.b
	}

	startMark := p.pt
	val, ok := p.parseRule(rule)
	p.setMemoized(startMark, rule, resultTuple{val, ok, p.pt})

	return val, ok
}

func (p *parser) parseRuleWrap(rule *rule) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseRule " + rule.name))
	}
	var (
		val       any
		ok        bool
		startMark = p.pt
	)

	if p.memoize {
		val, ok = p.parseRuleMemoize(rule)
	} else {
		val, ok = p.parseRule(rule)
	}

	if ok && p.debug {
		p.printIndent("MATCH", string(p.sliceFrom(startMark)))
	}
	return val, ok
}

func (p *parser) parseRule(rule *rule) (any, bool) {
	p.rstack = append(p.rstack, rule)
	p.pushV()
	val, ok := p.parseExprWrap(rule.expr)
	p.popV()
	p.rstack = p.rstack[:len(p.rstack)-1]
	return val, ok
}

func (p *parser) parseExprWrap(expr any) (any, bool) {
	var pt savepoint

	if p.memoize {
		res, ok := p.getMemoized(expr)
		if ok {
			p.restore(res.end)
			return res.v, res.b
		}
		pt = p.pt
	}

	val, ok := p.parseExpr(expr)

	if p.memoize {
		p.setMemoized(pt, expr, resultTuple{val, ok, p.pt})
	}
	return val, ok
}

func (p *parser) parseExpr(expr any) (any, bool) {
	p.ExprCnt++
	if p.ExprCnt > p.maxExprCnt {
		panic(errMaxExprCnt)
	}

	var val any
	var ok bool
	switch expr := expr.(type) {
	case *actionExpr:
		val, ok = p.parseActionExpr(expr)
	case *andCodeExpr:
		val, ok = p.parseAndCodeExpr(expr)
	case *andExpr:
		val, ok = p.parseAndExpr(expr)
	case *anyMatcher:
		val, ok = p.parseAnyMatcher(expr)
	case *charClassMatcher:
		val, ok = p.parseCharClassMatcher(expr)
	case *choiceExpr:
		val, ok = p.parseChoiceExpr(expr)
	case *labeledExpr:
		val, ok = p.parseLabeledExpr(expr)
	case *litMatcher:
		val, ok = p.parseLitMatcher(expr)
	case *notCodeExpr:
		val, ok = p.parseNotCodeExpr(expr)
	case *notExpr:
		val, ok = p.parseNotExpr(expr)
	case *oneOrMoreExpr:
		val, ok = p.parseOneOrMoreExpr(expr)
	case *recoveryExpr:
		val, ok = p.parseRecoveryExpr(expr)
	case *ruleRefExpr:
		val, ok = p.parseRuleRefExpr(expr)
	case *seqExpr:
		val, ok = p.parseSeqExpr(expr)
	case *stateCodeExpr:
		val, ok = p.parseStateCodeExpr(expr)
	case *throwExpr:
		val, ok = p.parseThrowExpr(expr)
	case *zeroOrMoreExpr:
		val, ok = p.parseZeroOrMoreExpr(expr)
	case *zeroOrOneExpr:
		val, ok = p.parseZeroOrOneExpr(expr)
	default:
		panic(fmt.Sprintf("unknown expression type %T", expr))
	}
	return val, ok
}

func (p *parser) parseActionExpr(act *actionExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseActionExpr"))
	}

	start := p.pt
	val, ok := p.parseExprWrap(act.expr)
	if ok {
		p.cur.pos = start.position
		p.cur.text = p.sliceFrom(start)
		state := p.cloneState()
		actVal, err := act.run(p)
		if err != nil {
			p.addErrAt(err, start.position, []string{})
		}
		p.restoreState(state)

		val = actVal
	}
	if ok && p.debug {
		p.printIndent("MATCH", string(p.sliceFrom(start)))
	}
	return val, ok
}

func (p *parser) parseAndCodeExpr(and *andCodeExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseAndCodeExpr"))
	}

	state := p.cloneState()

	ok, err := and.run(p)
	if err != nil {
		p.addErr(err)
	}
	p.restoreState(state)

	return nil, ok
}

func (p *parser) parseAndExpr(and *andExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseAndExpr"))
	}

	pt := p.pt
	state := p.cloneState()
	p.pushV()
	_, ok := p.parseExprWrap(and.expr)
	p.popV()
	p.restoreState(state)
	p.restore(pt)

	return nil, ok
}

func (p *parser) parseAnyMatcher(any *anyMatcher) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseAnyMatcher"))
	}

	if p.pt.rn == utf8.RuneError && p.pt.w == 0 {
		// EOF - see utf8.DecodeRune
		p.failAt(false, p.pt.position, ".")
		return nil, false
	}
	start := p.pt
	p.read()
	p.failAt(true, start.position, ".")
	return p.sliceFrom(start), true
}

func (p *parser) parseCharClassMatcher(chr *charClassMatcher) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseCharClassMatcher"))
	}

	cur := p.pt.rn
	start := p.pt

	// can't match EOF
	if cur == utf8.RuneError && p.pt.w == 0 { // see utf8.DecodeRune
		p.failAt(false, start.position, chr.val)
		return nil, false
	}

	if chr.ignoreCase {
		cur = unicode.ToLower(cur)
	}

	// try to match in the list of available chars
	for _, rn := range chr.chars {
		if rn == cur {
			if chr.inverted {
				p.failAt(false, start.position, chr.val)
				return nil, false
			}
			p.read()
			p.failAt(true, start.position, chr.val)
			return p.sliceFrom(start), true
		}
	}

	// try to match in the list of ranges
	for i := 0; i < len(chr.ranges); i += 2 {
		if cur >= chr.ranges[i] && cur <= chr.ranges[i+1] {
			if chr.inverted {
				p.failAt(false, start.position, chr.val)
				return nil, false
			}
			p.read()
			p.failAt(true, start.position, chr.val)
			return p.sliceFrom(start), true
		}
	}

	// try to match in the list of Unicode classes
	for _, cl := range chr.classes {
		if unicode.Is(cl, cur) {
			if chr.inverted {
				p.failAt(false, start.position, chr.val)
				return nil, false
			}
			p.read()
			p.failAt(true, start.position, chr.val)
			return p.sliceFrom(start), true
		}
	}

	if chr.inverted {
		p.read()
		p.failAt(true, start.position, chr.val)
		return p.sliceFrom(start), true
	}
	p.failAt(false, start.position, chr.val)
	return nil, false
}

func (p *parser) incChoiceAltCnt(ch *choiceExpr, altI int) {
	choiceIdent := fmt.Sprintf("%s %d:%d", p.rstack[len(p.rstack)-1].name, ch.pos.line, ch.pos.col)
	m := p.ChoiceAltCnt[choiceIdent]
	if m == nil {
		m = make(map[string]int)
		p.ChoiceAltCnt[choiceIdent] = m
	}
	// We increment altI by 1, so the keys do not start at 0
	alt := strconv.Itoa(altI + 1)
	if altI == choiceNoMatch {
		alt = p.choiceNoMatch
	}
	m[alt]++
}

func (p *parser) parseChoiceExpr(ch *choiceExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseChoiceExpr"))
	}

	for altI, alt := range ch.alternatives {
		// dummy assignment to prevent compile error if optimized
		_ = altI

		state := p.cloneState()

		p.pushV()
		val, ok := p.parseExprWrap(alt)
		p.popV()
		if ok {
			p.incChoiceAltCnt(ch, altI)
			return val, ok
		}
		p.restoreState(state)
	}
	p.incChoiceAltCnt(ch, choiceNoMatch)
	return nil, false
}

func (p *parser) parseLabeledExpr(lab *labeledExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseLabeledExpr"))
	}

	p.pushV()
	val, ok := p.parseExprWrap(lab.expr)
	p.popV()
	if ok && lab.label != "" {
		m := p.vstack[len(p.vstack)-1]
		m[lab.label] = val
	}
	return val, ok
}

func (p *parser) parseLitMatcher(lit *litMatcher) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseLitMatcher"))
	}

	start := p.pt
	for _, want := range lit.val {
		cur := p.pt.rn
		if lit.ignoreCase {
			cur = unicode.ToLower(cur)
		}
		if cur != want {
			p.failAt(false, start.position, lit.want)
			p.restore(start)
			return nil, false
		}
		p.read()
	}
	p.failAt(true, start.position, lit.want)
	return p.sliceFrom(start), true
}

func (p *parser) parseNotCodeExpr(not *notCodeExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseNotCodeExpr"))
	}

	state := p.cloneState()

	ok, err := not.run(p)
	if err != nil {
		p.addErr(err)
	}
	p.restoreState(state)

	return nil, !ok
}

func (p *parser) parseNotExpr(not *notExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseNotExpr"))
	}

	pt := p.pt
	state := p.cloneState()
	p.pushV()
	p.maxFailInvertExpected = !p.maxFailInvertExpected
	_, ok := p.parseExprWrap(not.expr)
	p.maxFailInvertExpected = !p.maxFailInvertExpected
	p.popV()
	p.restoreState(state)
	p.restore(pt)

	return nil, !ok
}

func (p *parser) parseOneOrMoreExpr(expr *oneOrMoreExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseOneOrMoreExpr"))
	}

	var vals []any

	for {
		p.pushV()
		val, ok := p.parseExprWrap(expr.expr)
		p.popV()
		if !ok {
			if len(vals) == 0 {
				// did not match once, no match
				return nil, false
			}
			return vals, true
		}
		vals = append(vals, val)
	}
}

func (p *parser) parseRecoveryExpr(recover *recoveryExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseRecoveryExpr (" + strings.Join(recover.failureLabel, ",") + ")"))
	}

	p.pushRecovery(recover.failureLabel, recover.recoverExpr)
	val, ok := p.parseExprWrap(recover.expr)
	p.popRecovery()

	return val, ok
}

func (p *parser) parseRuleRefExpr(ref *ruleRefExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseRuleRefExpr " + ref.name))
	}

	if ref.name == "" {
		panic(fmt.Sprintf("%s: invalid rule: missing name", ref.pos))
	}

	rule := p.rules[ref.name]
	if rule == nil {
		p.addErr(fmt.Errorf("undefined rule: %s", ref.name))
		return nil, false
	}
	return p.parseRuleWrap(rule)
}

func (p *parser) parseSeqExpr(seq *seqExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseSeqExpr"))
	}

	vals := make([]any, 0, len(seq.exprs))

	pt := p.pt
	state := p.cloneState()
	for _, expr := range seq.exprs {
		val, ok := p.parseExprWrap(expr)
		if !ok {
			p.restoreState(state)
			p.restore(pt)
			return nil, false
		}
		vals = append(vals, val)
	}
	return vals, true
}

func (p *parser) parseStateCodeExpr(state *stateCodeExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseStateCodeExpr"))
	}

	err := state.run(p)
	if err != nil {
		p.addErr(err)
	}
	return nil, true
}

func (p *parser) parseThrowExpr(expr *throwExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseThrowExpr"))
	}

	for i := len(p.recoveryStack) - 1; i >= 0; i-- {
		if recoverExpr, ok := p.recoveryStack[i][expr.label]; ok {
			if val, ok := p.parseExprWrap(recoverExpr); ok {
				return val, ok
			}
		}
	}

	return nil, false
}

func (p *parser) parseZeroOrMoreExpr(expr *zeroOrMoreExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseZeroOrMoreExpr"))
	}

	var vals []any

	for {
		p.pushV()
		val, ok := p.parseExprWrap(expr.expr)
		p.popV()
		if !ok {
			return vals, true
		}
		vals = append(vals, val)
	}
}

func (p *parser) parseZeroOrOneExpr(expr *zeroOrOneExpr) (any, bool) {
	if p.debug {
		defer p.out(p.in("parseZeroOrOneExpr"))
	}

	p.pushV()
	val, _ := p.parseExprWrap(expr.expr)
	p.popV()
	// whether it matched or not, consider it a match
	return val, true
}