diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0e9c9c3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,60 @@ +### Go ### + +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +# Go workspace file +go.work + +# Go Patch +/vendor/ +/Godeps/ + + +### macOS ### + +# General +.DS_Store +.AppleDouble +.LSOverride + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### macOS Patch ### +# iCloud generated files +*.icloud + + +### Others ### +build/ +.idea/ diff --git a/README.md b/README.md index 4f69151..b986002 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,126 @@ # archer Get help understanding your architecture. + +Please keep in mind that this is a work in progress, but it's already useful. + +## Workspace +To use it, first you need to import the information into a workspace, than +you can query and show graphs from it. + +A workspace can be set using the `-w` cli arg. Default is `./.archer` (if it exists) or `~/.archer`. + +## Roots and projects + +archer work with the idea of roots and projects. A project is a groping of source files or a +table, for ex, depending on the importer. + +A root is a groping of projects and allows to relate information from different sources. + +## Importing information + +### From gradle + +Run +``` +archer import gradle +``` + +All the projects will be imported. The root name is the name of the root gradle project. + + +### From hibernate + +Run +``` +archer import hibernate --root +``` + +Imports hibernate configuration from files inside the source paths. Currently only +kotlin files are supported, and information is gathered from annotations. + +The `source paths` can be a path on disk or a query (see below). + +The `root name` is required in this case and should be the schema name where the tables live. + +You can also use `--glob` to filter which files should be parsed. For ex: `--glob '**/Db*.kt'`. + + +### From MySQL + +Run +``` +archer import mysql +``` + +The `connection string` format is defined [here](https://github.com/go-sql-driver/mysql#dsn-data-source-name). + +All tables will be imported. The root name is the schema name. + + +## Configuring things + +You can use `archer config set` to add information to the projects. +Currently these are supported: + - ignore: does not output this project + - color: fixes the color to be used in graphs + + +## Showing data + +### Textual output + +Run +``` +archer show +``` + +### Graphs + +For this you need to have [graphviz dot](https://graphviz.org/) installed and in your path. + +Run +``` +archer graph -o +``` + +### Selecting what to see + +The simple version of the commands show all information available. This is usually too much, so +there are some parameters/filters to select what should be show. + +#### `-r ` +Only show information from one root + +### '-i ' +Only show information that matches the query (see below) + +### '-e ' +Don't show information that matches the query (see below) + +## Queries + +Queries allows you to select which projects are interesting. The supported formats are: + +### Project query: `:` or `` or `` +You can use `*` inside there to avoid some typing. + +### Any dependency query: ` -> ` +Shows any dependency chain that links project 1 to project 2 + +### Max steps dependency query: ` -N-> ` +`N` is a number. + +Shows any dependency chain that links project 1 to project 2, with at most N hops. + +### Invert query: `not:` +Inverts the matching. + +### Multiple matches required: ` & ` +To do an OR just pass different `-i` arguments. + + + + + + + diff --git a/build.go b/build.go new file mode 100644 index 0000000..1819288 --- /dev/null +++ b/build.go @@ -0,0 +1,22 @@ +//go:build ignore + +package main + +import ( + "github.com/pescuma/go-build" +) + +func main() { + cfg := build.NewBuilderConfig() + cfg.Archs = []string{"darwin"} + + b, err := build.NewBuilder(cfg) + if err != nil { + panic(err) + } + + err = b.RunTarget("all") + if err != nil { + panic(err) + } +} diff --git a/cmd/archer/cmdWithFilters.go b/cmd/archer/cmdWithFilters.go new file mode 100644 index 0000000..e695f31 --- /dev/null +++ b/cmd/archer/cmdWithFilters.go @@ -0,0 +1,44 @@ +package main + +import "github.com/Faire/archer/lib/archer" + +type cmdWithFilters struct { + Root []string `short:"r" help:"Only show projects from this root(s)."` + Include []string `short:"i" help:"Filter which projects or dependencies are shown."` + Exclude []string `short:"e" help:"Filter which projects or dependencies are NOT shown. This has preference over the included ones."` +} + +func (c *cmdWithFilters) createFilter(projs *archer.Projects) (archer.Filter, error) { + var filters []archer.Filter + + for _, f := range c.Include { + fi, err := archer.ParseFilter(projs, f, archer.Include) + if err != nil { + return nil, err + } + + filters = append(filters, fi) + } + + for _, f := range c.Exclude { + fi, err := archer.ParseFilter(projs, f, archer.Exclude) + if err != nil { + return nil, err + } + + filters = append(filters, fi) + } + + filters = append(filters, archer.CreateIgnoreFilter()) + + if len(c.Root) > 0 { + f, err := archer.CreateRootsFilter(c.Root) + if err != nil { + return nil, err + } + + filters = append(filters, f) + } + + return archer.GroupFilters(filters...), nil +} diff --git a/cmd/archer/config.go b/cmd/archer/config.go new file mode 100644 index 0000000..f71d212 --- /dev/null +++ b/cmd/archer/config.go @@ -0,0 +1,40 @@ +package main + +import ( + "fmt" + + "github.com/Faire/archer/lib/archer" +) + +type ConfigSetCmd struct { + Project string `arg:"" help:"Project filter to configure."` + Config string `arg:"" help:"Configuration name to change."` + Value string `arg:"" help:"Configuration value to set."` +} + +func (c *ConfigSetCmd) Run(ctx *context) error { + projects, err := ctx.ws.LoadProjects() + if err != nil { + return err + } + + filter, err := archer.ParseFilter(projects, c.Project, archer.Include) + if err != nil { + return err + } + + for _, p := range projects.ListProjects(archer.FilterExcludeExternal) { + if filter.FilterProject(p) != archer.Include { + continue + } + + fmt.Printf("Seting '%v' '%v' = '%v'\n", p.Name, c.Config, c.Value) + + _, err := ctx.ws.SetConfigParameter(p, c.Config, c.Value) + if err != nil { + return err + } + } + + return nil +} diff --git a/cmd/archer/graph.go b/cmd/archer/graph.go new file mode 100644 index 0000000..bad209c --- /dev/null +++ b/cmd/archer/graph.go @@ -0,0 +1,380 @@ +package main + +import ( + "fmt" + "math" + "os" + "os/exec" + "path/filepath" + "sort" + "strings" + + "github.com/dustin/go-humanize" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/utils" +) + +type GraphCmd struct { + cmdWithFilters + + Output string `short:"o" default:"deps.png" help:"Output file to write." type:"path"` + Levels int `short:"l" help:"How many levels of subprojects should be considered."` + Lines bool `default:"true" negatable:"" help:"Scale nodes by the number of lines."` +} + +func (c *GraphCmd) Run(ctx *context) error { + projects, err := ctx.ws.LoadProjects() + if err != nil { + return err + } + + filter, err := c.createFilter(projects) + if err != nil { + return err + } + + dot := c.generateDot(projects, filter) + + gv := c.Output + ".gv" + + fmt.Printf("Creating dot file: %v\n", gv) + + err = os.WriteFile(gv, []byte(dot), 0o600) + if err != nil { + return err + } + + format := filepath.Ext(c.Output) + if format == "" { + c.Output += ".png" + format = "png" + } else { + format = format[1:] + } + + fmt.Printf("Generating output graph: %v\n", c.Output) + + cmd := exec.Command("dot", gv, "-T"+format, "-o", c.Output) + err = cmd.Run() + if err != nil { + return err + } + + err = os.Remove(gv) + if err != nil { + return err + } + + return nil +} + +func (c *GraphCmd) generateDot(projects *archer.Projects, filter archer.Filter) string { + ps := projects.ListProjects(archer.FilterExcludeExternal) + + getProjectName := func(p *archer.Project) string { + result := p.LevelSimpleName(c.Levels) + result = strings.TrimSuffix(result, "-api") + return result + } + + tg := groupByRoot(ps, filter, true, getProjectName) + + nodes := map[string]*node{} + colors := c.computeColors(ps, getProjectName) + showSizes, computeGraphSize := c.computeSizesConfig(tg) + + o := newOutput() + o.addLine(`digraph G {`) + + for _, rg := range tg.children { + o.addLine(`subgraph "cluster_%v" {`, rg.name) + + if showSizes && !rg.size.isEmpty() { + o.addLine(`label = <%v
%v>`, rg.name, rg.size.html()) + } else { + o.addLine(`label = "%v"`, rg.name) + } + + for _, pg := range rg.children { + n, ok := nodes[pg.fullName] + if !ok { + n = newNode(pg.fullName) + n.attribs["color"] = colors[pg.fullName] + + nodes[pg.fullName] = n + } + + if showSizes && !pg.size.isEmpty() { + n.attribs["shape"] = "circle" + n.attribs["fixedsize"] = "shape" + n.attribs["width"] = humanize.FormatFloat("#.##", computeGraphSize(pg.size.get())) + + n.attribs["label"] = fmt.Sprintf(`<%v
%v>`, + pg.name, + pg.size.html(), + ) + } else { + n.attribs["label"] = pg.name + } + + o.addLineDistinct(n) + } + + o.addLine("}") + o.addLine("") + } + + for _, rg := range tg.children { + for _, pg := range rg.children { + for _, dg := range pg.children { + e := newEdge(pg.fullName, dg.fullName) + e.attribs["color"] = colors[dg.fullName] + e.attribs["style"] = dg.dep.GetConfig("style") + + o.addLineDistinct(e) + } + } + } + o.addLine("") + + if showSizes && !tg.size.isEmpty() { + o.addLine("{ rank = sink; legend_Total [shape=plaintext label=%v>] }", tg.size.html()) + } + + o.addLine("}") + + return o.String() +} + +func (c *GraphCmd) computeSizesConfig(tg *group) (bool, func(int) float64) { + ls := []int{-1, -1} + for _, rg := range tg.children { + for _, pg := range rg.children { + s := pg.size.get() + if s > 0 { + if ls[0] == -1 { + ls[0] = s + ls[1] = s + } else { + ls[0] = utils.Min(ls[0], s) + ls[1] = utils.Max(ls[1], s) + } + } + } + } + + showSizes := c.Lines && ls[0] != -1 + + sizeRange := []float64{0.5, 2} + if showSizes && ls[1] > 10*ls[0] { + sizeRange = []float64{0.1, 10.0} + } + + return showSizes, func(size int) float64 { + f := float64(size-ls[0]) / float64(ls[1]) + f = math.Sqrt(f) + return utils.Max(f*(sizeRange[1]), sizeRange[0]) + } +} + +func (c *GraphCmd) computeNodesShow(ps []*archer.Project, filter archer.Filter) map[string]bool { + show := map[string]bool{} + + for _, p := range ps { + show[p.Name] = false + } + + for _, p := range ps { + if !show[p.Name] { + show[p.Name] = filter.Decide(filter.FilterProject(p)) != archer.Exclude + } + + for _, d := range p.ListDependencies(archer.FilterExcludeExternal) { + if filter.Decide(filter.FilterDependency(d)) == archer.Exclude { + continue + } + + show[d.Source.Name] = true + show[d.Target.Name] = true + } + } + + return show +} + +func (c *GraphCmd) computeColors(ps []*archer.Project, getProjectName func(p *archer.Project) string) map[string]string { + availableColors := []string{ + "#1abc9c", + "#16a085", + "#2ecc71", + "#27ae60", + "#3498db", + "#2980b9", + "#9b59b6", + "#8e44ad", + "#34495e", + "#2c3e50", + // "#f1c40f", + "#f39c12", + "#e67e22", + "#d35400", + // "#e74c3c", + // "#c0392b", + // "#ecf0f1", + // "#bdc3c7", + "#95a5a6", + "#7f8c8d", + } + aci := 0 + + colors := map[string]string{} + + for _, p := range ps { + pn := p.Root + ":" + getProjectName(p) + + color := p.GetConfig("color") + if color != "" { + colors[pn] = color + + } else { + color = availableColors[aci] + aci = (aci + 1) % len(availableColors) + colors[pn] = color + } + } + + return colors +} + +type output struct { + sb strings.Builder + indent string + prev map[string]bool +} + +func newOutput() *output { + return &output{ + prev: map[string]bool{}, + } +} + +func (o *output) addLine(format string, a ...any) { + l := fmt.Sprintf(format, a...) + + if strings.HasPrefix(l, "}") { + o.decreaseIndent() + } + + o.sb.WriteString(o.indent + l + "\n") + + if strings.HasSuffix(l, "{") { + o.increaseIndent() + } +} + +func (o *output) addLineDistinct(s any) { + l := fmt.Sprint(s) + + if !o.prev[l] { + o.addLine(l) + o.prev[l] = true + } +} + +func (o *output) increaseIndent() { + o.indent += " " +} + +func (o *output) decreaseIndent() { + o.indent = o.indent[:len(o.indent)-3] +} + +func (o *output) String() string { + return o.sb.String() +} + +type node struct { + name string + files int + attribs map[string]string +} + +func newNode(name string) *node { + return &node{ + name: name, + attribs: map[string]string{}, + } +} + +func (n *node) String() string { + sb := strings.Builder{} + + sb.WriteString(fmt.Sprintf(`"%v"`, n.name)) + writeAttribs(&sb, n.attribs) + sb.WriteString(";") + + return sb.String() +} + +type edge struct { + src string + dest string + attribs map[string]string +} + +func newEdge(src, dest string) *edge { + return &edge{ + src: src, + dest: dest, + attribs: map[string]string{}, + } +} + +func (e *edge) String() string { + sb := strings.Builder{} + + sb.WriteString(fmt.Sprintf(`"%v" -> "%v"`, e.src, e.dest)) + writeAttribs(&sb, e.attribs) + sb.WriteString(";") + + return sb.String() +} + +func writeAttribs(sb *strings.Builder, attribs map[string]string) { + keys := sortedKeys(attribs) + + if len(keys) == 0 { + return + } + + sb.WriteString(" [") + + for _, k := range keys { + v := attribs[k] + + if strings.HasPrefix(v, "<") && strings.HasSuffix(v, ">") { + sb.WriteString(fmt.Sprintf(` "%v"=%v`, k, v)) + } else { + sb.WriteString(fmt.Sprintf(` "%v"="%v"`, k, v)) + } + } + + sb.WriteString(" ]") +} + +func sortedKeys(d map[string]string) []string { + result := make([]string, 0, len(d)) + + for k, v := range d { + if v != "" { + result = append(result, k) + } + } + + sort.Slice(result, func(i, j int) bool { + return result[i] < result[j] + }) + + return result +} diff --git a/cmd/archer/import.go b/cmd/archer/import.go new file mode 100644 index 0000000..342b045 --- /dev/null +++ b/cmd/archer/import.go @@ -0,0 +1,39 @@ +package main + +import ( + "github.com/Faire/archer/lib/archer/gradle" + "github.com/Faire/archer/lib/archer/hibernate" + "github.com/Faire/archer/lib/archer/mysql" +) + +type ImportGradleCmd struct { + Path string `arg:"" help:"Path with root of gradle project." type:"existingpath"` +} + +func (c *ImportGradleCmd) Run(ctx *context) error { + g := gradle.NewImporter(c.Path) + + return ctx.ws.Import(g) +} + +type ImportHibernateCmd struct { + Path []string `arg:"" help:"Path with root of projects to search." type:"existingpath"` + Glob []string `help:"Glob limiting files to be processed."` + Root string `default:"db" help:"Root name for the projects."` +} + +func (c *ImportHibernateCmd) Run(ctx *context) error { + g := hibernate.NewImporter(c.Path, c.Glob, c.Root) + + return ctx.ws.Import(g) +} + +type ImportMySqlCmd struct { + ConnectionString string `arg:"" help:"MySQL connection string."` +} + +func (c *ImportMySqlCmd) Run(ctx *context) error { + g := mysql.NewImporter(c.ConnectionString) + + return ctx.ws.Import(g) +} diff --git a/cmd/archer/main.go b/cmd/archer/main.go new file mode 100644 index 0000000..928d25a --- /dev/null +++ b/cmd/archer/main.go @@ -0,0 +1,40 @@ +package main + +import ( + "github.com/alecthomas/kong" + + "github.com/Faire/archer/lib/archer" +) + +var cli struct { + Workspace string `short:"w" help:"Workspace to store data. Default is ./.archer or ~/.archer if that does not exist." type:"path"` + + Show ShowCmd `cmd:"" help:"Show the dependencies of projects inside a json file."` + Graph GraphCmd `cmd:"" help:"Generate dependencies graph. Requires dot in path."` + + Config struct { + Set ConfigSetCmd `cmd:"" help:"Set configuration parameters."` + } `cmd:""` + + Import struct { + Gradle ImportGradleCmd `cmd:"" help:"Import information from gradle project."` + Hibernate ImportHibernateCmd `cmd:"" help:"Import information from hibernate annotation in classes."` + Mysql ImportMySqlCmd `cmd:"" help:"Import information from MySQL schema."` + } `cmd:""` +} + +type context struct { + ws *archer.Workspace +} + +func main() { + ctx := kong.Parse(&cli, kong.ShortUsageOnError()) + + workspace, err := archer.NewWorkspace(cli.Workspace) + ctx.FatalIfErrorf(err) + + err = ctx.Run(&context{ + ws: workspace, + }) + ctx.FatalIfErrorf(err) +} diff --git a/cmd/archer/show.go b/cmd/archer/show.go new file mode 100644 index 0000000..9782480 --- /dev/null +++ b/cmd/archer/show.go @@ -0,0 +1,98 @@ +package main + +import ( + "fmt" + + "github.com/Faire/archer/lib/archer" +) + +type ShowCmd struct { + cmdWithFilters + + Levels int `short:"l" help:"How many levels of subprojects should be considered."` + Simple bool `short:"s" help:"Only show project names"` +} + +func (c *ShowCmd) Run(ctx *context) error { + projects, err := ctx.ws.LoadProjects() + if err != nil { + return err + } + + filter, err := c.createFilter(projects) + if err != nil { + return err + } + + c.print(projects, filter) + + return nil +} + +func (c *ShowCmd) print(projects *archer.Projects, filter archer.Filter) { + ps := projects.ListProjects(archer.FilterExcludeExternal) + + tg := groupByRoot(ps, filter, false, func(p *archer.Project) string { + return p.LevelSimpleName(c.Levels) + }) + + for _, rg := range tg.children { + c.println("", "Root", rg.name, rg.size.text()) + + for _, pg := range rg.children { + c.println(" ", "Project", pg.name, pg.size.text()) + + if !c.Simple { + for _, dg := range pg.children { + c.println(" ", "depends on", dg.name, "") + } + } + } + + fmt.Println() + } + + if !c.Simple && !tg.size.isEmpty() { + c.println("", "Total", "", tg.size.text()) + } +} + +func (c *ShowCmd) computeNodesShow(ps []*archer.Project, filter archer.Filter) map[string]bool { + show := map[string]bool{} + + for _, p := range ps { + show[p.Name] = false + } + + for _, p := range ps { + if !show[p.Name] { + show[p.Name] = filter.Decide(filter.FilterProject(p)) != archer.Exclude + } + + for _, d := range p.ListDependencies(archer.FilterExcludeExternal) { + if filter.Decide(filter.FilterDependency(d)) == archer.Exclude { + continue + } + + show[p.Name] = true + } + } + + return show +} + +func (c *ShowCmd) println(prefix, category, name, size string) { + switch { + case c.Simple: + fmt.Printf("%v%v\n", prefix, name) + + case size == "": + fmt.Printf("%v%v %v\n", prefix, category, name) + + case name == "": + fmt.Printf("%v%v: %v\n", prefix, category, size) + + default: + fmt.Printf("%v%v %v [%v]\n", prefix, category, name, size) + } +} diff --git a/cmd/archer/sizes.go b/cmd/archer/sizes.go new file mode 100644 index 0000000..9f46b98 --- /dev/null +++ b/cmd/archer/sizes.go @@ -0,0 +1,97 @@ +package main + +import ( + "fmt" + "strings" + + "github.com/dustin/go-humanize" + + "github.com/Faire/archer/lib/archer" +) + +type sizes struct { + elements int + lines int + files int + bytes int +} + +func (s *sizes) isEmpty() bool { + return s.get() == 0 +} + +func (s *sizes) add(size archer.Size) { + s.elements++ + s.lines += size.Lines + s.files += size.Files + s.bytes += size.Bytes +} + +func (s *sizes) get() int { + switch { + case s.bytes > 0: + return s.bytes + case s.lines > 0: + return s.lines + case s.files > 0: + return s.files + default: + return 0 + } +} + +func (s *sizes) text() string { + ts := s.prepareText() + if len(ts) == 0 { + return "" + } + + result := strings.Join(ts, ", ") + + if s.elements > 1 { + result = "∑ " + result + } + + return result +} + +func (s *sizes) html() string { + ts := s.prepareText() + if len(ts) == 0 { + return "" + } + + if s.elements > 1 { + for i := range ts { + ts[i] = "∑ " + ts[i] + } + } + + result := strings.Join(ts, "
") + + return result +} + +func (s *sizes) prepareText() []string { + var result []string + + if s.lines > 0 { + t := humanize.Bytes(uint64(s.lines)) + t = strings.TrimSuffix(t, "B") + t = strings.TrimSpace(t) + result = append(result, fmt.Sprintf("%v lines", t)) + } + + if s.files > 0 { + t := humanize.Bytes(uint64(s.files)) + t = strings.TrimSuffix(t, "B") + t = strings.TrimSpace(t) + result = append(result, fmt.Sprintf("%v files", t)) + } + + if s.bytes > 0 { + result = append(result, fmt.Sprintf("%v", humanize.IBytes(uint64(s.bytes)))) + } + + return result +} diff --git a/cmd/archer/utils.go b/cmd/archer/utils.go new file mode 100644 index 0000000..2e62dee --- /dev/null +++ b/cmd/archer/utils.go @@ -0,0 +1,153 @@ +package main + +import ( + "sort" + + "github.com/samber/lo" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/utils" +) + +func groupByRoot(ps []*archer.Project, filter archer.Filter, forceShowDependentProjects bool, projGrouping func(project *archer.Project) string) *group { + show := computeNodesShow(ps, filter, forceShowDependentProjects) + + ps = lo.Filter(ps, func(p *archer.Project, _ int) bool { return show[p.FullName()] }) + + rs := lo.GroupBy(ps, func(p *archer.Project) string { return p.Root }) + + keys := lo.Keys(rs) + sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + + tg := group{ + category: TotalCategory, + } + + for _, k := range keys { + rps := rs[k] + + rg := &group{ + category: RootCategory, + name: k, + fullName: k, + } + tg.children = append(tg.children, rg) + + pgs := map[string]*group{} + dgs := map[string]*group{} + + for _, p := range rps { + pgn := projGrouping(p) + pgfn := p.Root + ":" + pgn + + pg, ok := pgs[pgfn] + if !ok { + pg = &group{ + category: ProjectCategory, + name: pgn, + fullName: pgfn, + proj: p, + } + pgs[pgfn] = pg + rg.children = append(rg.children, pg) + } + + size := p.GetSize() + pg.size.add(size) + rg.size.add(size) + tg.size.add(size) + + for _, d := range p.ListDependencies(archer.FilterExcludeExternal) { + if filter.Decide(filter.FilterDependency(d)) == archer.Exclude { + continue + } + + dgn := projGrouping(d.Target) + dgfn := d.Target.Root + ":" + dgn + + if pgfn == dgfn { + continue + } + + dg, ok := dgs[pgfn+"\n"+dgfn] + if !ok { + dg = &group{ + category: DependencyCategory, + name: utils.IIf(p.Root == d.Target.Root, dgn, dgfn), + fullName: dgfn, + dep: d, + } + dgs[pgfn+"\n"+dgfn] = dg + pg.children = append(pg.children, dg) + } + + dg.size.lines++ + } + } + } + + sort.Slice(tg.children, func(i, j int) bool { + return tg.children[i].fullName < tg.children[j].fullName + }) + for _, rg := range tg.children { + sort.Slice(rg.children, func(i, j int) bool { + return rg.children[i].fullName < rg.children[j].fullName + }) + + for _, pg := range rg.children { + sort.Slice(pg.children, func(i, j int) bool { + return pg.children[i].fullName < pg.children[j].fullName + }) + } + } + + return &tg +} + +func computeNodesShow(ps []*archer.Project, filter archer.Filter, forceShowDependentProjects bool) map[string]bool { + show := map[string]bool{} + + for _, p := range ps { + show[p.FullName()] = false + } + + for _, p := range ps { + if !show[p.FullName()] { + show[p.FullName()] = filter.Decide(filter.FilterProject(p)) != archer.Exclude + } + + for _, d := range p.ListDependencies(archer.FilterExcludeExternal) { + if filter.Decide(filter.FilterDependency(d)) == archer.Exclude { + continue + } + + show[d.Source.FullName()] = true + + if forceShowDependentProjects { + show[d.Target.FullName()] = true + } + } + } + + return show +} + +type group struct { + category groupCategory + name string + fullName string + size sizes + children []*group + + proj *archer.Project + dep *archer.Dependency +} + +type groupCategory int + +const ( + TotalCategory groupCategory = iota + RootCategory + ProjectCategory + DependencyCategory +) diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..5192c80 --- /dev/null +++ b/go.mod @@ -0,0 +1,36 @@ +module github.com/Faire/archer + +go 1.19 + +require ( + github.com/alecthomas/kong v0.6.1 + github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846 + github.com/bmatcuk/doublestar/v4 v4.2.0 + github.com/dustin/go-humanize v1.0.0 + github.com/gertd/go-pluralize v0.2.1 + github.com/go-sql-driver/mysql v1.6.0 + github.com/hhatto/gocloc v0.4.3 + github.com/pkg/errors v0.9.1 + github.com/samber/lo v1.31.0 + github.com/stretchr/testify v1.8.0 + golang.org/x/exp v0.0.0-20220929160808-de9c53c655b9 +) + +require ( + github.com/Masterminds/semver/v3 v3.1.1 // indirect + github.com/aymanbagabas/go-osc52 v1.0.3 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/go-enry/go-enry/v2 v2.8.0 // indirect + github.com/go-enry/go-oniguruma v1.2.1 // indirect + github.com/google/licensecheck v0.3.1 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-isatty v0.0.16 // indirect + github.com/mattn/go-runewidth v0.0.14 // indirect + github.com/muesli/termenv v0.13.0 // indirect + github.com/pescuma/go-build v0.0.0-20221021034732-538c218430a0 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/rivo/uniseg v0.2.0 // indirect + golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect + golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..45f1270 --- /dev/null +++ b/go.sum @@ -0,0 +1,82 @@ +github.com/Masterminds/semver/v3 v3.1.1 h1:hLg3sBzpNErnxhQtUy/mmLR2I9foDujNK030IGemrRc= +github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs= +github.com/alecthomas/kong v0.6.1 h1:1kNhcFepkR+HmasQpbiKDLylIL8yh5B5y1zPp5bJimA= +github.com/alecthomas/kong v0.6.1/go.mod h1:JfHWDzLmbh/puW6I3V7uWenoh56YNVONW+w8eKeUr9I= +github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142 h1:8Uy0oSf5co/NZXje7U1z8Mpep++QJOldL2hs/sBQf48= +github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8= +github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846 h1:et5J11AOyUn9qwkIAF9kcxTxjTO8Z9oSmlOqH7MVSPo= +github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20220911224424-aa1f1f12a846/go.mod h1:pSwJ0fSY5KhvocuWSx4fz3BA8OrA1bQn+K1Eli3BRwM= +github.com/aymanbagabas/go-osc52 v1.0.3 h1:DTwqENW7X9arYimJrPeGZcV0ln14sGMt3pHZspWD+Mg= +github.com/aymanbagabas/go-osc52 v1.0.3/go.mod h1:zT8H+Rk4VSabYN90pWyugflM3ZhpTZNC7cASDfUCdT4= +github.com/bmatcuk/doublestar/v4 v4.2.0 h1:Qu+u9wR3Vd89LnlLMHvnZ5coJMWKQamqdz9/p5GNthA= +github.com/bmatcuk/doublestar/v4 v4.2.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/gertd/go-pluralize v0.2.1 h1:M3uASbVjMnTsPb0PNqg+E/24Vwigyo/tvyMTtAlLgiA= +github.com/gertd/go-pluralize v0.2.1/go.mod h1:rbYaKDbsXxmRfr8uygAEKhOWsjyrrqrkHVpZvoOp8zk= +github.com/go-enry/go-enry/v2 v2.8.0 h1:KMW4mSG+8uUF6FaD3iPkFqyfC5tF8gRrsYImq6yhHzo= +github.com/go-enry/go-enry/v2 v2.8.0/go.mod h1:GVzIiAytiS5uT/QiuakK7TF1u4xDab87Y8V5EJRpsIQ= +github.com/go-enry/go-oniguruma v1.2.1 h1:k8aAMuJfMrqm/56SG2lV9Cfti6tC4x8673aHCcBk+eo= +github.com/go-enry/go-oniguruma v1.2.1/go.mod h1:bWDhYP+S6xZQgiRL7wlTScFYBe023B6ilRZbCAD5Hf4= +github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE= +github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= +github.com/google/licensecheck v0.3.1 h1:QoxgoDkaeC4nFrtGN1jV7IPmDCHFNIVh54e5hSt6sPs= +github.com/google/licensecheck v0.3.1/go.mod h1:ORkR35t/JjW+emNKtfJDII0zlciG9JgbT7SmsohlHmY= +github.com/hhatto/gocloc v0.4.3 h1:bWbEi+cOKDAvWwPsP2lT30638Bg37X+Ru00TG7adpGg= +github.com/hhatto/gocloc v0.4.3/go.mod h1:EPoonh5stxIeraUU70Ogyj9yIpvV6Xirnjhyx+3/cHM= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= +github.com/mattn/go-isatty v0.0.16 h1:bq3VjFmv/sOjHtdEhmkEV4x1AJtvUvOJ2PFAZ5+peKQ= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU= +github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/muesli/termenv v0.13.0 h1:wK20DRpJdDX8b7Ek2QfhvqhRQFZ237RGRO0RQ/Iqdy0= +github.com/muesli/termenv v0.13.0/go.mod h1:sP1+uffeLaEYpyOTb8pLCUctGcGLnoFjSn4YJK5e2bc= +github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= +github.com/pescuma/go-build v0.0.0-20221021034732-538c218430a0 h1:TZemLC3oTJpwu8oABax6nw/WkKLCzZewLNO34CKBXhk= +github.com/pescuma/go-build v0.0.0-20221021034732-538c218430a0/go.mod h1:9ZvZnZf+YujhKEkYNych2xGT3ZzZ9zx3maQZA/5lKkw= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/samber/lo v1.31.0 h1:Sfa+/064Tdo4SvlohQUQzBhgSer9v/coGvKQI/XLWAM= +github.com/samber/lo v1.31.0/go.mod h1:HLeWcJRRyLKp3+/XBJvOrerCQn9mhdKMHyd7IRlgeQ8= +github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc= +github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/thoas/go-funk v0.9.1 h1:O549iLZqPpTUQ10ykd26sZhzD+rmR5pWhuElrhbC20M= +golang.org/x/exp v0.0.0-20220929160808-de9c53c655b9 h1:lNtcVz/3bOstm7Vebox+5m3nLh/BYWnhmc3AhXOW6oI= +golang.org/x/exp v0.0.0-20220929160808-de9c53c655b9/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/lib/archer/common/naming.go b/lib/archer/common/naming.go new file mode 100644 index 0000000..838b1a4 --- /dev/null +++ b/lib/archer/common/naming.go @@ -0,0 +1,52 @@ +package common + +import ( + "strings" + + "github.com/gertd/go-pluralize" + + "github.com/Faire/archer/lib/archer" +) + +func CreateTableNameParts(projs []*archer.Project) { + pc := pluralize.NewClient() + + plurals := 0 + + for _, proj := range projs { + if pc.IsPlural(proj.Name) { + plurals++ + } + } + + convertToPlural := plurals > len(projs)/2 + + for _, proj := range projs { + pieces := strings.Split(proj.Name, "_") + + parts := make([]string, 0, len(pieces)) + + for i := range pieces { + part := strings.Join(pieces[:i+1], "_") + + if part == "" { + continue + } + + switch { + case i == len(pieces)-1: + part = proj.Name + + case convertToPlural: + part = pc.Plural(part) + + default: + part = pc.Singular(part) + } + + parts = append(parts, part) + } + + proj.NameParts = parts + } +} diff --git a/lib/archer/common/naming_test.go b/lib/archer/common/naming_test.go new file mode 100644 index 0000000..ea49886 --- /dev/null +++ b/lib/archer/common/naming_test.go @@ -0,0 +1,28 @@ +package common_test + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/common" +) + +func TestCreateTableNameParts(t *testing.T) { + t.Parallel() + + assert.Equal(t, []string{"a"}, createTableNameParts("a")) + assert.Equal(t, []string{"a", "a_b"}, createTableNameParts("a_b")) + assert.Equal(t, []string{"a", "a_b", "a_b_c"}, createTableNameParts("a_b_c")) +} + +func createTableNameParts(name string) []string { + projs := archer.NewProjects() + + proj := projs.Get("r", name) + + common.CreateTableNameParts(projs.ListProjects(archer.FilterAll)) + + return proj.NameParts +} diff --git a/lib/archer/filters.go b/lib/archer/filters.go new file mode 100644 index 0000000..f487c54 --- /dev/null +++ b/lib/archer/filters.go @@ -0,0 +1,428 @@ +package archer + +import ( + "regexp" + "strconv" + "strings" + + "github.com/pkg/errors" + "github.com/samber/lo" + + "github.com/Faire/archer/lib/archer/utils" +) + +func CreateIgnoreFilter() Filter { + return &basicFilter{ + filterProject: func(proj *Project) UsageType { + return utils.IIf(proj.IsIgnored(), Exclude, DontCare) + }, + filterDependency: func(dep *Dependency) UsageType { + return utils.IIf(dep.Source.IsIgnored() || dep.Target.IsIgnored(), Exclude, DontCare) + }, + filterType: Exclude, + } +} + +func CreateRootsFilter(roots []string) (Filter, error) { + var fs []func(string) bool + + for _, r := range roots { + f, err := parseFilterBool(r) + if err != nil { + return nil, err + } + + fs = append(fs, f) + } + + matches := func(proj *Project) bool { + for _, f := range fs { + if f(proj.Root) { + return true + } + } + + return false + } + + return &basicFilter{ + filterProject: func(proj *Project) UsageType { + return utils.IIf(matches(proj), DontCare, Exclude) + }, + filterDependency: func(dep *Dependency) UsageType { + return utils.IIf(matches(dep.Source) && matches(dep.Target), DontCare, Exclude) + }, + filterType: Exclude, + }, nil +} + +func ParseFilter(projs *Projects, filter string, filterType UsageType) (Filter, error) { + switch { + case filter == "": + return &basicFilter{}, nil + + case strings.Index(filter, "&") >= 0: + result := &andFilter{} + + for _, fi := range strings.Split(filter, "&") { + fi = strings.TrimSpace(fi) + if fi == "" { + continue + } + + f, err := ParseFilter(projs, fi, filterType) + if err != nil { + return nil, err + } + + result.filters = append(result.filters, f) + } + + return result, nil + + case strings.Index(filter, "->") >= 0: + return ParseEdgeFilter(projs, filter, filterType) + + default: + return ParseProjectFilter(projs, filter, filterType) + } +} + +func ParseProjectFilter(projs *Projects, filter string, filterType UsageType) (Filter, error) { + projFilter, err := parseProjectFilterBool(filter) + if err != nil { + return nil, err + } + + return &basicFilter{ + filterProject: func(src *Project) UsageType { + if !projFilter(src) { + return DontCare + } + + return filterType + }, + filterDependency: func(dep *Dependency) UsageType { + sm := projFilter(dep.Source) + dm := projFilter(dep.Target) + + if filterType == Include { + return utils.IIf(sm && dm, Include, DontCare) + + } else { + return utils.IIf(sm || dm, Exclude, DontCare) + } + }, + filterType: filterType, + }, nil +} + +func ParseEdgeFilter(projs *Projects, filter string, filterType UsageType) (Filter, error) { + re := regexp.MustCompile(`^([^>]*?)\s*(?:-(\d+)?(R)?)?->\s*([^>]*)$`) + + parts := re.FindStringSubmatch(filter) + if parts == nil { + return nil, errors.Errorf("invalid edge filter: %v", filter) + } + + srcFilter, err := parseProjectFilterBool(parts[1]) + if err != nil { + return nil, err + } + + maxDepth := -1 + if parts[2] != "" { + maxDepth, err = strconv.Atoi(parts[2]) + if err != nil { + return nil, err + } + } + + onlyRequiredEdges := false + if parts[3] == "R" { + onlyRequiredEdges = true + } + + destFilter, _ := parseProjectFilterBool(parts[4]) + if err != nil { + return nil, err + } + + matches := map[string]map[string]int{} + + for _, src := range projs.ListProjects(FilterExcludeExternal) { + if !srcFilter(src) { + continue + } + + visited := map[string]int{} + findMatchingEdges(matches, visited, maxDepth, []*Project{src}, destFilter) + } + + nodes := map[string]int{} + for s, m := range matches { + nodes[s] = 1 + for d := range m { + nodes[d] = 1 + } + } + + return &basicFilter{ + filterDependency: func(dep *Dependency) UsageType { + if filterType == Include && !onlyRequiredEdges { + return utils.IIf(utils.MapContains(nodes, dep.Source.Name) && utils.MapContains(nodes, dep.Target.Name), Include, DontCare) + } else { + return utils.IIf(utils.MapMapContains(matches, dep.Source.Name, dep.Target.Name), filterType, DontCare) + } + }, + filterType: filterType, + }, nil +} + +func findMatchingEdges(matches map[string]map[string]int, visited map[string]int, maxDepth int, path []*Project, destFilter func(proj *Project) bool) { + add := func(a, b *Project) { + m, ok := matches[a.Name] + if !ok { + m = map[string]int{} + matches[a.Name] = m + } + + m[b.Name] = 1 + } + + addPath := func() { + p := path[0] + for _, n := range path[1:] { + add(p, n) + p = n + } + } + + src := utils.First(path) + dest := utils.Last(path) + + if dest.IsIgnored() { + return + + } else if dest != src && destFilter(dest) { + addPath() + + } else if maxDepth == 0 { + return + + } else if utils.MapContains(visited, dest.Name) { + return + + } else { + visited[dest.Name] = 1 + + for _, next := range dest.ListDependencies(FilterExcludeExternal) { + if utils.MapMapContains(matches, dest.Name, next.Target.Name) { + // This will lead us to a destination, so no need to go down this road + addPath() + + } else { + findMatchingEdges(matches, visited, maxDepth-1, append(path, next.Target), destFilter) + } + } + } +} + +func parseProjectFilterBool(filter string) (func(proj *Project) bool, error) { + filter = strings.TrimSpace(filter) + + if strings.HasPrefix(filter, "!") { + f, err := parseProjectFilterBool(filter[1:]) + if err != nil { + return nil, err + } + + return func(proj *Project) bool { + return !f(proj) + }, nil + + } else if filter == "" { + return func(proj *Project) bool { + return true + }, nil + + } else if strings.HasPrefix(filter, "root:") { + f, err := parseFilterBool(strings.TrimPrefix(filter, "root:")) + if err != nil { + return nil, err + } + + return func(proj *Project) bool { + return f(proj.Root) + }, nil + + } else { + f, err := parseFilterBool(filter) + if err != nil { + return nil, err + } + + return func(proj *Project) bool { + return f(proj.Name) || f(proj.SimpleName()) || f(proj.FullName()) + }, nil + } +} + +func parseFilterBool(filter string) (func(string) bool, error) { + if strings.HasPrefix(filter, "re:") { + re, err := regexp.Compile("(?i)" + strings.TrimPrefix(filter, "re:")) + if err != nil { + return nil, errors.Wrapf(err, "invalid project RE: %v", filter) + } + + return re.MatchString, nil + + } else if strings.Index(filter, "*") >= 0 { + filterRE := strings.ReplaceAll(filter, `\`, `\\`) + filterRE = strings.ReplaceAll(filterRE, `.`, `\.`) + filterRE = strings.ReplaceAll(filterRE, `(`, `\(`) + filterRE = strings.ReplaceAll(filterRE, `)`, `\)`) + filterRE = strings.ReplaceAll(filterRE, `^`, `\^`) + filterRE = strings.ReplaceAll(filterRE, `$`, `\$`) + filterRE = strings.ReplaceAll(filterRE, `*`, `.*`) + + re, err := regexp.Compile("(?i)^" + filterRE + "$") + if err != nil { + return nil, errors.Wrapf(err, "invalid project filter: %v", filter) + } + + return re.MatchString, nil + + } else { + return func(s string) bool { + return strings.EqualFold(s, filter) + }, nil + } +} + +func GroupFilters(filters ...Filter) Filter { + return &multipleFilter{filters} +} + +type Filter interface { + FilterProject(proj *Project) UsageType + + FilterDependency(dep *Dependency) UsageType + + // Decide does not return DontCase, so it should decide what to do in this case + Decide(u UsageType) UsageType +} + +type UsageType int + +const ( + DontCare UsageType = iota + Include + Exclude // Exclude has preference over Include +) + +func (u UsageType) Merge(other UsageType) UsageType { + switch { + case u == other: + return u + case u == Exclude || other == Exclude: + return Exclude + default: // One of them is Include, because they have 2 different values + return Include + } +} + +type basicFilter struct { + filterProject func(proj *Project) UsageType + filterDependency func(dep *Dependency) UsageType + filterType UsageType +} + +func (b *basicFilter) FilterProject(proj *Project) UsageType { + if b.filterProject == nil { + return DontCare + } + + return b.filterProject(proj) +} + +func (b *basicFilter) FilterDependency(dep *Dependency) UsageType { + if b.filterDependency == nil { + return DontCare + } + + return b.filterDependency(dep) +} + +func (b *basicFilter) Decide(u UsageType) UsageType { + switch { + case u == DontCare && b.filterType == Exclude: + return Include + case u == DontCare && b.filterType == Include: + return Exclude + default: + return u + } +} + +type andFilter struct { + filters []Filter +} + +func (m *andFilter) FilterProject(proj *Project) UsageType { + result := lo.Map(m.filters, func(f Filter, _ int) UsageType { return f.FilterProject(proj) }) + result = lo.Uniq(result) + + if len(result) != 1 { + return DontCare + } else { + return result[0] + } +} + +func (m *andFilter) FilterDependency(dep *Dependency) UsageType { + result := lo.Map(m.filters, func(f Filter, _ int) UsageType { return f.FilterDependency(dep) }) + result = lo.Uniq(result) + + if len(result) != 1 { + return DontCare + } else { + return result[0] + } +} + +func (m *andFilter) Decide(u UsageType) UsageType { + result := utils.IIf(u == DontCare, Include, u) + for _, f := range m.filters { + result = result.Merge(f.Decide(u)) + } + return result +} + +type multipleFilter struct { + filters []Filter +} + +func (m *multipleFilter) FilterProject(proj *Project) UsageType { + result := DontCare + for _, f := range m.filters { + result = result.Merge(f.FilterProject(proj)) + } + return result +} + +func (m *multipleFilter) FilterDependency(dep *Dependency) UsageType { + result := DontCare + for _, f := range m.filters { + result = result.Merge(f.FilterDependency(dep)) + } + return result +} + +func (m *multipleFilter) Decide(u UsageType) UsageType { + result := utils.IIf(u == DontCare, Include, u) + for _, f := range m.filters { + result = result.Merge(f.Decide(u)) + } + return result +} diff --git a/lib/archer/gradle/gradle_importer.go b/lib/archer/gradle/gradle_importer.go new file mode 100644 index 0000000..c74acc6 --- /dev/null +++ b/lib/archer/gradle/gradle_importer.go @@ -0,0 +1,356 @@ +package gradle + +import ( + "fmt" + "io/fs" + "os" + "os/exec" + "path/filepath" + "regexp" + "strings" + + "github.com/hhatto/gocloc" + "github.com/pkg/errors" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/utils" +) + +type gradleImporter struct { + rootDir string + storage *archer.Storage +} + +func NewImporter(rootDir string) archer.Importer { + return &gradleImporter{ + rootDir: rootDir, + } +} + +func (g *gradleImporter) Import(projs *archer.Projects, storage *archer.Storage) error { + g.storage = storage + + fmt.Printf("Listing projects...\n") + + queue, err := g.importProjectNames() + if err != nil { + return err + } + + fmt.Printf("Going to import basic info from %v projects...\n", len(queue)) + + rootProj := queue[0] + + for i, p := range queue { + changed, err := g.importBasicInfo(projs, p, rootProj) + if err != nil { + return err + } + + prefix := fmt.Sprintf("[%v / %v] ", i, len(queue)) + + if !changed { + fmt.Printf("%vSkipped import of basic info from '%v'\n", prefix, p) + } else { + fmt.Printf("%vImported basic info from '%v'\n", prefix, p) + } + } + + fmt.Printf("Going to import dependencies from %v projects...\n", len(queue)) + + block := 100 + for i := 0; i < len(queue); { + piece := utils.Take(queue[i:], block) + + for _, p := range piece { + i++ + prefix := fmt.Sprintf("[%v / %v] ", i, len(queue)) + fmt.Printf("%vImporting dependencies from '%v' ...\n", prefix, p) + } + + err = g.loadDependencies(projs, piece, rootProj) + if err != nil { + return err + } + } + + for _, p := range queue { + proj := projs.Get(rootProj, p) + + for _, d := range proj.ListDependencies(archer.FilterAll) { + if d.Source.IsCode() && strings.HasSuffix(d.Source.Name, "-api") { + d.SetConfig("source", strings.TrimSuffix(d.Source.Name, "-api")) + } + if d.Target.IsCode() && strings.HasSuffix(d.Target.Name, "-api") { + d.SetConfig("target", strings.TrimSuffix(d.Target.Name, "-api")) + d.SetConfig("type", "api") + d.SetConfig("style", "dashed") + } + } + + err = g.storage.WriteDepsFile(proj) + if err != nil { + return err + } + } + + fmt.Printf("Going to import lines of code from %v projects...\n", len(queue)) + + for i, p := range queue { + changed, err := g.importSize(projs, rootProj, p) + if err != nil { + return err + } + + prefix := fmt.Sprintf("[%v / %v] ", i, len(queue)) + + if !changed { + fmt.Printf("%vSkipped import of lines of code from '%v'\n", prefix, p) + } else { + fmt.Printf("%vImported lines of code from '%v'\n", prefix, p) + } + } + + return nil +} + +func (g *gradleImporter) importProjectNames() ([]string, error) { + projNames, err := listProjects(g.rootDir) + if err != nil { + return nil, err + } + + fileName, err := g.storage.GetProjNamesFileName(g.rootDir) + if err != nil { + return nil, err + } + + err = g.storage.WriteProjNamesFile(fileName, projNames[0], projNames) + if err != nil { + return nil, err + } + + return projNames, nil +} + +func (g *gradleImporter) importBasicInfo(projs *archer.Projects, projName string, rootProj string) (bool, error) { + projDir, err := g.getProjectDir(projName) + if err != nil { + return false, err + } + + projFile, err := g.getProjectFile(projName) + if err != nil { + return false, err + } + + proj := projs.Get(rootProj, projName) + proj.NameParts = utils.IIf(projName == rootProj, []string{rootProj}, strings.Split(projName[1:], ":")) + proj.Root = rootProj + proj.Type = archer.CodeType + proj.RootDir = g.rootDir + proj.ProjectFile = projFile + + proj.Dir = filepath.Join(projDir, "src") + if _, err = os.Stat(proj.Dir); err != nil { + proj.Dir = "" + } + + err = g.storage.WriteBasicInfoFile(proj) + if err != nil { + return false, err + } + + return true, nil +} + +func (g *gradleImporter) getProjectDir(projName string) (string, error) { + if projName[0] == ':' { + return filepath.Abs(filepath.Join( + g.rootDir, + strings.ReplaceAll(projName[1:], ":", string(os.PathSeparator)), + )) + + } else { + return g.rootDir, nil + } +} + +func (g *gradleImporter) getProjectFile(projName string) (string, error) { + dir, err := g.getProjectDir(projName) + if err != nil { + return "", err + } + + entries, err := os.ReadDir(dir) + if err != nil { + return "", err + } + + for _, e := range entries { + if strings.HasPrefix(e.Name(), "build.gradle.") { + return filepath.Join(dir, e.Name()), nil + } + } + + return "", nil +} + +func (g *gradleImporter) loadDependencies(projs *archer.Projects, projNamesToImport []string, rootProj string) error { + args := make([]string, 0, 3*len(projNamesToImport)) + for _, projName := range projNamesToImport { + var target string + if strings.HasPrefix(projName, ":") { + target = projName + ":dependencies" + } else { + target = "dependencies" + } + + args = append(args, target, "--configuration", "compileClasspath") + } + + cmd := exec.Command(filepath.Join(g.rootDir, "gradlew"), args...) + cmd.Dir = g.rootDir + + output, err := cmd.Output() + if err != nil { + return err + } + + opt := splitOutputPerTarget(string(output)) + + for _, o := range opt { + err = parseDeps(projs, o, rootProj) + if err != nil { + return err + } + } + + return nil +} + +func splitOutputPerTarget(output string) map[string]string { + result := map[string]string{} + + re := regexp.MustCompile(`^> Task (:[^ ]+)$`) + task := "" + start := -1 + + lines := strings.Split(output, "\n") + for i, l := range lines { + m := re.FindStringSubmatch(l) + if m != nil { + if start != -1 { + result[task] = strings.Join(lines[start:i], "\n") + } + + task = strings.TrimSuffix(m[1], ":dependencies") + start = i + 1 + continue + } + } + + if start != -1 { + result[task] = strings.Join(lines[start:], "\n") + } + + return result +} + +func (g *gradleImporter) needsUpdate(projFile string, depsJson string) (bool, error) { + sp, err := os.Stat(projFile) + if err != nil { + // No project file means no deps + return false, nil + } + + sd, err := os.Stat(depsJson) + + return err != nil || sp.ModTime().After(sd.ModTime()), nil +} + +func (g *gradleImporter) importSize(projs *archer.Projects, rootProj, projName string) (bool, error) { + proj := projs.Get(rootProj, projName) + + if proj.Dir == "" { + return false, nil + } + + es, err := os.ReadDir(proj.Dir) + if err != nil { + return false, err + } + for _, e := range es { + if !e.IsDir() { + continue + } + + size, err := g.computeCLOC(filepath.Join(proj.Dir, e.Name())) + if err != nil { + return false, err + } + + proj.AddSize(e.Name(), *size) + } + + err = g.storage.WriteSizeFile(proj) + if err != nil { + return false, err + } + + return true, nil +} + +func (g *gradleImporter) computeCLOC(path string) (*archer.Size, error) { + result := archer.Size{ + Other: map[string]int{}, + } + + _, err := os.Stat(path) + switch { + case os.IsNotExist(err): + return nil, nil + case err != nil: + return nil, err + } + + languages := gocloc.NewDefinedLanguages() + options := gocloc.NewClocOptions() + paths := []string{ + path, + } + + processor := gocloc.NewProcessor(languages, options) + loc, err := processor.Analyze(paths) + if err != nil { + return nil, errors.Wrapf(err, "error computing lones of code") + } + + files := 0 + bytes := 0 + err = filepath.WalkDir(path, func(path string, d fs.DirEntry, err error) error { + if !d.IsDir() { + info, err := d.Info() + if err != nil { + return err + } + + files += 1 + bytes += int(info.Size()) + } + + return nil + }) + if err != nil { + return nil, err + } + + result.Bytes = bytes + result.Files = files + result.Other["Code"] = int(loc.Total.Code) + result.Other["Comments"] = int(loc.Total.Comments) + result.Other["Blanks"] = int(loc.Total.Blanks) + result.Lines = int(loc.Total.Code + loc.Total.Comments + loc.Total.Blanks) + + return &result, nil +} diff --git a/lib/archer/gradle/parse.go b/lib/archer/gradle/parse.go new file mode 100644 index 0000000..f13e52e --- /dev/null +++ b/lib/archer/gradle/parse.go @@ -0,0 +1,121 @@ +package gradle + +import ( + "os/exec" + "path/filepath" + "regexp" + "strings" + + "github.com/pkg/errors" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/utils" +) + +func listProjects(rootDir string) ([]string, error) { + cmd := exec.Command(filepath.Join(rootDir, "gradlew"), "projects") + cmd.Dir = rootDir + + output, err := cmd.Output() + if err != nil { + return nil, err + } + + result, err := parseProjects(string(output)) + if err != nil { + return nil, err + } + + return result, nil +} + +func parseProjects(content string) ([]string, error) { + rootRE := regexp.MustCompile(`^Root project '([^']+)'$`) + projRE := regexp.MustCompile(`^[-+\\| ]+Project '([^']+)'$`) + + var result []string + + rootAdded := false + lines := strings.Split(content, "\n") + for _, l := range lines { + if !rootAdded { + m := rootRE.FindStringSubmatch(l) + if m != nil { + result = append(result, m[1]) + rootAdded = true + } + } + + m := projRE.FindStringSubmatch(l) + if m != nil { + result = append(result, m[1]) + } + } + + return result, nil +} + +func parseDeps(projects *archer.Projects, content string, rootProj string) error { + rootProjRE := regexp.MustCompile(`^(?:Root project|Project) '([^']+)'$`) + depRE := regexp.MustCompile(`^([-+\\| ]+)(?:project )?([a-zA-Z0-9:._-]+)`) + + state := waitingRoot + var stack []pd + + lines := strings.Split(content, "\n") + for _, l := range lines { + if state == waitingRoot { + rootMatches := rootProjRE.FindStringSubmatch(l) + if rootMatches != nil { + p := projects.Get(rootProj, rootMatches[1]) + stack = append(stack, pd{p, 0}) + state = waitingDeps + } + continue + } + + if state == waitingDeps { + if strings.HasPrefix(l, "\\---") || strings.HasPrefix(l, "+---") { + state = parsingDeps + } + } + + if state == parsingDeps { + if len(l) == 0 { + break + } + + depMatches := depRE.FindStringSubmatch(l) + if depMatches == nil { + return errors.Errorf("invalid dependency line: %v", l) + } + + depth := len(depMatches[1]) + p := projects.Get(rootProj, depMatches[2]) + + lp := utils.Last(stack) + for depth <= lp.depth { + stack = utils.RemoveLast(stack) + lp = utils.Last(stack) + } + + lp.proj.AddDependency(p) + stack = append(stack, pd{p, depth}) + } + } + + return nil +} + +type parseState int + +const ( + waitingRoot parseState = iota + waitingDeps + parsingDeps +) + +type pd struct { + proj *archer.Project + depth int +} diff --git a/lib/archer/hibernate/hibernate_imoprter_test.go b/lib/archer/hibernate/hibernate_imoprter_test.go new file mode 100644 index 0000000..a2b1636 --- /dev/null +++ b/lib/archer/hibernate/hibernate_imoprter_test.go @@ -0,0 +1,26 @@ +package hibernate + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestCleanTypeName(t *testing.T) { + t.Parallel() + + assert.Equal(t, "Abc", cleanTypeName("Abc")) + assert.Equal(t, "Abc", cleanTypeName("Abc?")) + assert.Equal(t, "Abc", cleanTypeName("List")) + assert.Equal(t, "Abc", cleanTypeName("MutableList")) + assert.Equal(t, "Abc", cleanTypeName("Set")) + assert.Equal(t, "Abc", cleanTypeName("MutableSet")) + assert.Equal(t, "Abc", cleanTypeName("List?")) + assert.Equal(t, "Abc", cleanTypeName("MutableList?")) + assert.Equal(t, "Abc", cleanTypeName("Set?")) + assert.Equal(t, "Abc", cleanTypeName("MutableSet?")) + assert.Equal(t, "Abc", cleanTypeName("List")) + assert.Equal(t, "Abc", cleanTypeName("MutableList")) + assert.Equal(t, "Abc", cleanTypeName("Set")) + assert.Equal(t, "Abc", cleanTypeName("MutableSet")) +} diff --git a/lib/archer/hibernate/hibernate_importer.go b/lib/archer/hibernate/hibernate_importer.go new file mode 100644 index 0000000..afc9158 --- /dev/null +++ b/lib/archer/hibernate/hibernate_importer.go @@ -0,0 +1,541 @@ +package hibernate + +import ( + "fmt" + "io/fs" + "os" + "path/filepath" + "regexp" + "sort" + "strings" + + "github.com/antlr/antlr4/runtime/Go/antlr/v4" + "github.com/bmatcuk/doublestar/v4" + "github.com/pkg/errors" + "github.com/samber/lo" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/common" + "github.com/Faire/archer/lib/archer/kotlin_parser" + "github.com/Faire/archer/lib/archer/utils" +) + +type hibernateImporter struct { + rootDirs []string + globs []string + storage *archer.Storage + rootName string +} + +func NewImporter(rootDirs, globs []string, rootName string) archer.Importer { + return &hibernateImporter{ + rootDirs: rootDirs, + globs: globs, + rootName: rootName, + } +} + +func (h *hibernateImporter) Import(projs *archer.Projects, storage *archer.Storage) error { + h.storage = storage + + roots, err := h.computeRootDirs(projs) + if err != nil { + return err + } + + for _, r := range roots { + fmt.Printf("%v %v %v\n", r.dir, r.parentRoot, r.parentName) + + } + + type work struct { + root rootInfo + fileName string + fileContents string + classes map[string]*classInfo + errors []string + } + + group := utils.NewProcessGroup(func(w *work) (*work, error) { + var err error + w.classes, w.errors, err = h.processKotlin(w.fileContents, w.fileName, w.root) + return w, err + }) + + go func() { + for _, root := range roots { + globs := make([]string, len(h.globs)) + for i, g := range h.globs { + if !filepath.IsAbs(g) { + g = filepath.Join(root.dir, g) + } + + globs[i] = g + } + + err = filepath.WalkDir(root.dir, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return filepath.SkipDir + } + + if group.Aborted() { + return errors.New("aborted") + } + + if d.IsDir() && strings.HasPrefix(d.Name(), ".") { + return filepath.SkipDir + } + + if !strings.HasSuffix(path, ".kt") { + return nil + } + + match := len(globs) == 0 + for _, g := range globs { + m, err := doublestar.PathMatch(g, path) + if err != nil { + return err + } + if m { + match = true + } + } + + if !match { + return nil + } + + contents, err := os.ReadFile(path) + if err != nil { + return err + } + + group.Input <- &work{ + root: root, + fileName: path, + fileContents: string(contents), + } + + return nil + }) + if err != nil { + group.Abort(err) + return + } + } + + group.FinishedInput() + }() + + classes := map[string]*classInfo{} + var errors []string + for w := range group.Output { + for k, nv := range w.classes { + ov, ok := classes[k] + if !ok { + classes[k] = nv + + } else { + ov.Root = append(ov.Root, nv.Root...) + ov.Paths = append(ov.Paths, nv.Paths...) + ov.Tables = append(ov.Tables, nv.Tables...) + ov.Dependencies = append(ov.Dependencies, nv.Dependencies...) + } + } + + errors = append(errors, w.errors...) + } + + if err = <-group.Err; err != nil { + return err + } + + for _, e := range errors { + fmt.Printf("ERROR: %v\n", e) + } + + dbProjs := map[string]*archer.Project{} + parentProjs := map[string]*archer.Project{} + + for _, c := range classes { + if len(c.Paths) != 1 { + fmt.Printf("ERROR: %v is associated with more than one path: %v. Ignoring!\n", c.Name, strings.Join(c.Paths, ", ")) + continue + } + if len(c.Tables) != 1 { + fmt.Printf("ERROR: %v is associated with more than one table: %v. Ignoring!\n", c.Name, strings.Join(c.Tables, ", ")) + continue + } + + root := c.Root[0] + + proj := projs.Get(h.rootName, c.Tables[0]) + dbProjs[proj.FullName()] = proj + + proj.Type = archer.DatabaseType + proj.RootDir = root.dir + proj.Dir = filepath.Dir(c.Paths[0]) + proj.ProjectFile = c.Paths[0] + + if root.parentName != "" { + parent := projs.Get(root.parentRoot, root.parentName) + parentProjs[parent.FullName()] = parent + + parent.AddDependency(proj) + } + + for _, di := range c.Dependencies { + dc, ok := classes[di.ClassName] + if !ok { + fmt.Printf("ERROR: %v depends on unknown class: %v. Ignoring!\n", c.Name, di.ClassName) + continue + } + + if len(dc.Paths) != 1 { + fmt.Printf("ERROR: %v depends on %v wich is associated with more than one path: %v. Ignoring!\n", c.Name, di.ClassName, strings.Join(dc.Paths, ", ")) + continue + } + if len(dc.Tables) != 1 { + fmt.Printf("ERROR: %v depends on %v wich is associated with more than one table: %v. Ignoring!\n", c.Name, di.ClassName, strings.Join(dc.Tables, ", ")) + continue + } + + dp := projs.Get(h.rootName, dc.Tables[0]) + dbProjs[dp.FullName()] = dp + + d := proj.AddDependency(dp) + + if di.Lazy { + d.SetConfig("type", "lazy") + d.SetConfig("style", "dashed") + } + } + } + + common.CreateTableNameParts(lo.Values(dbProjs)) + + for _, proj := range dbProjs { + err = storage.WriteBasicInfoFile(proj) + if err != nil { + return err + } + + err = storage.WriteDepsFile(proj) + if err != nil { + return err + } + } + + for _, proj := range parentProjs { + err = storage.WriteDepsFile(proj) + if err != nil { + return err + } + } + + return nil +} + +type rootInfo struct { + parentRoot string + parentName string + dir string +} + +func (h *hibernateImporter) computeRootDirs(projs *archer.Projects) ([]rootInfo, error) { + paths := map[rootInfo]bool{} + + for _, rootDir := range h.rootDirs { + switch { + case strings.HasPrefix(rootDir, "archer:"): + filter, err := archer.ParseFilter(projs, strings.TrimPrefix(rootDir, "archer:"), archer.Include) + if err != nil { + return nil, err + } + + for _, p := range projs.ListProjects(archer.FilterExcludeExternal) { + if filter.Decide(filter.FilterProject(p)) == archer.Include { + paths[rootInfo{p.Root, p.Name, p.Dir}] = true + } + + for _, d := range p.ListDependencies(archer.FilterExcludeExternal) { + if filter.Decide(filter.FilterDependency(d)) == archer.Include { + paths[rootInfo{d.Source.Root, d.Source.Name, d.Source.Dir}] = true + paths[rootInfo{d.Target.Root, d.Target.Name, d.Target.Dir}] = true + } + } + } + + default: + dir, err := utils.PathAbs(rootDir) + if err != nil { + return nil, err + } + + paths[rootInfo{"", "", dir}] = true + } + } + + result := make([]rootInfo, 0, len(paths)) + for k := range paths { + if k.dir != "" { + result = append(result, k) + } + } + + sort.Slice(result, func(i, j int) bool { + return result[i].dir < result[j].dir + }) + + return result, nil +} + +func (h *hibernateImporter) processKotlin(fileContents string, fileName string, root rootInfo) (map[string]*classInfo, []string, error) { + l := newTreeListener(fileName, root) + + l.Printfln("Parsing %v ...", fileName) + l.IncreasePrefix() + defer func() { + l.DecreasePrefix() + fmt.Print(l.sb.String()) + }() + + input := antlr.NewInputStream(fileContents) + lexer := kotlin_parser.NewKotlinLexer(input) + stream := antlr.NewCommonTokenStream(lexer, 0) + + p := kotlin_parser.NewKotlinParser(stream) + + file := p.KotlinFile() + + antlr.ParseTreeWalkerDefault.Walk(l, file) + + return l.Classes, l.Errors, nil +} + +type treeListener struct { + *kotlin_parser.BaseKotlinParserListener + root rootInfo + currentPath string + currentClassName []string + currentClass []*classInfo + insideFunction int + insideProperty bool + + hasColumnAnnotation bool + hasLazyAnnotation bool + currentVariableType string + + sb strings.Builder + prefix string + + Classes map[string]*classInfo + Errors []string +} + +type classInfo struct { + Name string + Root []rootInfo + Paths []string + Tables []string + Dependencies []*dependencyInfo +} + +type dependencyInfo struct { + ClassName string + Lazy bool +} + +var tableRE = regexp.MustCompile(`name\s*=\s*"([^'"]+)"`) +var genericContainterRE = regexp.MustCompile(`Of<([^>]+)>\(`) + +func newTreeListener(path string, root rootInfo) *treeListener { + return &treeListener{ + currentPath: path, + root: root, + Classes: map[string]*classInfo{}, + } +} + +func (l *treeListener) Printfln(format string, a ...any) { + l.sb.WriteString(fmt.Sprintf(l.prefix+format+"\n", a...)) +} + +func (l *treeListener) IncreasePrefix() { + l.prefix += " " +} + +func (l *treeListener) DecreasePrefix() { + l.prefix = l.prefix[:len(l.prefix)-3] +} + +func (l *treeListener) EnterClassDeclaration(ctx *kotlin_parser.ClassDeclarationContext) { + name := ctx.SimpleIdentifier().GetText() + if len(l.currentClassName) > 0 { + name = utils.Last(l.currentClassName) + "." + name + } + + l.currentClassName = append(l.currentClassName, name) + l.currentClass = append(l.currentClass, nil) + + l.Printfln("found class %v", name) + l.IncreasePrefix() +} + +func (l *treeListener) ExitClassDeclaration(ctx *kotlin_parser.ClassDeclarationContext) { + l.DecreasePrefix() + + l.currentClassName = utils.RemoveLast(l.currentClassName) + l.currentClass = utils.RemoveLast(l.currentClass) +} + +func (l *treeListener) EnterFunctionDeclaration(ctx *kotlin_parser.FunctionDeclarationContext) { + l.insideFunction++ +} + +func (l *treeListener) ExitFunctionDeclaration(ctx *kotlin_parser.FunctionDeclarationContext) { + l.insideFunction-- +} + +func (l *treeListener) EnterPropertyDeclaration(ctx *kotlin_parser.PropertyDeclarationContext) { + if l.insideFunction > 0 || len(l.currentClass) == 0 || utils.Last(l.currentClass) == nil { + return + } + + l.insideProperty = true + l.hasColumnAnnotation = false + l.hasLazyAnnotation = false + l.currentVariableType = "" + + if ctx.VariableDeclaration() == nil { + panic(fmt.Sprintf("Only supported one variable per property declaration (in %v %v)", + l.currentPath, utils.Last(l.currentClassName))) + } +} + +func (l *treeListener) ExitPropertyDeclaration(ctx *kotlin_parser.PropertyDeclarationContext) { + if !l.insideProperty { + return + } + l.insideProperty = false + + if !l.hasColumnAnnotation { + return + } + + if l.currentVariableType == "" { + if ctx.Expression() != nil { + exp := ctx.Expression().GetText() + ms := genericContainterRE.FindStringSubmatch(exp) + if ms != nil { + l.currentVariableType = ms[1] + } + } + } + + l.currentVariableType = cleanTypeName(l.currentVariableType) + + varDecl := ctx.VariableDeclaration() + + l.Printfln("found field %v", varDecl.GetText()) + l.IncreasePrefix() + + if l.currentVariableType == "" { + l.Printfln("could not find type of field") + l.Errors = append(l.Errors, fmt.Sprintf("Could not find type of field %v %v %v", + l.currentPath, utils.Last(l.currentClassName), varDecl.GetText())) + + } else { + l.addDependency(l.currentVariableType, l.hasLazyAnnotation) + } + + l.DecreasePrefix() +} + +func (l *treeListener) ExitVariableDeclaration(ctx *kotlin_parser.VariableDeclarationContext) { + if type_ := ctx.Type_(); type_ != nil { + l.currentVariableType = type_.GetText() + } +} + +func (l *treeListener) EnterUnescapedAnnotation(ctx *kotlin_parser.UnescapedAnnotationContext) { + text := ctx.GetText() + parts := strings.SplitN(text, "(", 2) + if len(parts) == 1 { + parts = append(parts, "") + } + + if parts[0] == "Table" { + ms := tableRE.FindStringSubmatch(parts[1]) + if ms != nil { + l.addTable(ms[1]) + } + + } else if parts[0] == "JoinColumn" { + l.hasColumnAnnotation = true + + } else if parts[0] == "ManyToOne" || parts[0] == "OneToMany" || parts[0] == "OneToOne" { + l.hasLazyAnnotation = strings.Index(parts[1], "FetchType.LAZY") >= 0 + } +} + +func (l *treeListener) addTable(tableName string) { + l.Printfln("adding table: %v", tableName) + + cls := l.getClass(utils.Last(l.currentClassName)) + cls.Root = append(cls.Root, l.root) + cls.Paths = append(cls.Paths, l.currentPath) + cls.Tables = append(cls.Tables, tableName) + + l.currentClass[len(l.currentClass)-1] = cls +} + +func (l *treeListener) addDependency(dependencyTypeName string, lazy bool) { + l.Printfln("adding dep: %v%v", dependencyTypeName, utils.IIf(lazy, " (lazy)", "")) + + cls := utils.Last(l.currentClass) + cls.Dependencies = append(cls.Dependencies, &dependencyInfo{ + ClassName: dependencyTypeName, + Lazy: lazy, + }) +} + +func (l *treeListener) getClass(name string) *classInfo { + result, ok := l.Classes[name] + + if !ok { + result = &classInfo{ + Name: name, + } + l.Classes[name] = result + } + + return result +} + +var genericRE = regexp.MustCompile(`^([^<]+)<(.*?)>\??$`) + +func cleanTypeName(t string) string { + t = strings.TrimSpace(t) + + for { + matches := genericRE.FindStringSubmatch(t) + if matches == nil { + break + } + + t1 := matches[1] + t2 := matches[2] + + if t1 == "MutableList" || t1 == "List" || t1 == "MutableSet" || t1 == "Set" { + t = t2 + + } else { + t = t1 + break + } + } + + t = strings.TrimSuffix(t, "?") + return t +} diff --git a/lib/archer/import.go b/lib/archer/import.go new file mode 100644 index 0000000..86cddd8 --- /dev/null +++ b/lib/archer/import.go @@ -0,0 +1,5 @@ +package archer + +type Importer interface { + Import(projs *Projects, storage *Storage) error +} diff --git a/lib/archer/json.go b/lib/archer/json.go new file mode 100644 index 0000000..0b7a7cc --- /dev/null +++ b/lib/archer/json.go @@ -0,0 +1,220 @@ +package archer + +import ( + "encoding/json" + "path/filepath" +) + +func ProjNamesToJson(root string, names []string) (string, error) { + jps := jsonProjNames{ + Root: root, + Names: names, + } + + marshaled, err := json.Marshal(jps) + if err != nil { + return "", err + } + + return string(marshaled), nil +} + +func ProjNamesFromJson(content string) (string, []string, error) { + var jps jsonProjNames + + err := json.Unmarshal([]byte(content), &jps) + if err != nil { + return "", nil, err + } + + return jps.Root, jps.Names, nil +} + +func BasicInfoToJson(proj *Project) (string, error) { + jps := jsonBasicInfo{ + Root: proj.Root, + Name: proj.Name, + NameParts: proj.NameParts, + Type: proj.Type, + + RootDir: proj.RootDir, + Dir: proj.Dir, + ProjectFile: proj.ProjectFile, + } + + marshaled, err := json.Marshal(jps) + if err != nil { + return "", err + } + + return string(marshaled), nil +} + +func BasicInfoFromJson(result *Projects, content string, fileName string) error { + var jps jsonBasicInfo + + err := json.Unmarshal([]byte(content), &jps) + if err != nil { + return err + } + + proj := result.Get(jps.Root, jps.Name) + proj.NameParts = jps.NameParts + proj.Type = jps.Type + proj.RootDir = jps.RootDir + proj.Dir = jps.Dir + proj.ProjectFile = jps.ProjectFile + proj.dataDir = filepath.Dir(fileName) + + return nil +} + +func DepsToJson(proj *Project) (string, error) { + ds := proj.ListDependencies(FilterAll) + + jps := jsonDeps{ + Root: proj.Root, + Name: proj.Name, + Deps: make([]jsonDep, 0, len(ds)), + } + + for _, d := range ds { + jp := jsonDep{ + TargetRoot: d.Target.Root, + TargetName: d.Target.Name, + Config: d.config, + } + + jps.Deps = append(jps.Deps, jp) + } + + marshaled, err := json.Marshal(jps) + if err != nil { + return "", err + } + + return string(marshaled), nil +} + +func DepsFromJson(result *Projects, content string) error { + var jps jsonDeps + + err := json.Unmarshal([]byte(content), &jps) + if err != nil { + return err + } + + proj := result.Get(jps.Root, jps.Name) + for _, jp := range jps.Deps { + target := result.Get(jp.TargetRoot, jp.TargetName) + + d := proj.AddDependency(target) + d.config = jp.Config + } + + return nil +} + +func SizeToJson(proj *Project) (string, error) { + jps := jsonSize{ + Root: proj.Root, + Name: proj.Name, + Size: proj.size, + } + + marshaled, err := json.Marshal(jps) + if err != nil { + return "", err + } + + return string(marshaled), nil +} + +func SizeFromJson(result *Projects, content string) error { + var jps jsonSize + + err := json.Unmarshal([]byte(content), &jps) + if err != nil { + return err + } + + proj := result.Get(jps.Root, jps.Name) + + for k, v := range jps.Size { + proj.AddSize(k, v) + } + + return nil +} + +func ConfigToJson(proj *Project) (string, error) { + jps := jsonConfig{ + Root: proj.Root, + Name: proj.Name, + Config: proj.config, + } + + marshaled, err := json.Marshal(jps) + if err != nil { + return "", err + } + + return string(marshaled), nil +} + +func ConfigFromJson(result *Projects, content string) error { + var jps jsonConfig + + err := json.Unmarshal([]byte(content), &jps) + if err != nil { + return err + } + + proj := result.Get(jps.Root, jps.Name) + + for k, v := range jps.Config { + proj.SetConfig(k, v) + } + + return nil +} + +type jsonProjNames struct { + Root string + Names []string +} + +type jsonBasicInfo struct { + Root string + Name string + NameParts []string + Type ProjectType + + RootDir string + Dir string + ProjectFile string +} + +type jsonDeps struct { + Root string + Name string + Deps []jsonDep +} + +type jsonDep struct { + TargetRoot string + TargetName string + Config map[string]string +} + +type jsonSize struct { + Root string + Name string + Size map[string]Size +} + +type jsonConfig struct { + Root string + Name string + Config map[string]string +} diff --git a/lib/archer/kotlin_parser/KotlinLexer.g4 b/lib/archer/kotlin_parser/KotlinLexer.g4 new file mode 100644 index 0000000..17e14b4 --- /dev/null +++ b/lib/archer/kotlin_parser/KotlinLexer.g4 @@ -0,0 +1,527 @@ +/** + * Kotlin lexical grammar in ANTLR4 notation + */ + +lexer grammar KotlinLexer; + +import UnicodeClasses; + +// SECTION: lexicalGeneral + +ShebangLine + : '#!' ~[\r\n]* + ; + +DelimitedComment + : '/*' ( DelimitedComment | . )*? '*/' + -> channel(HIDDEN) + ; + +LineComment + : '//' ~[\r\n]* + -> channel(HIDDEN) + ; + +WS + : [\u0020\u0009\u000C] + -> channel(HIDDEN) + ; + +NL: '\n' | '\r' '\n'?; + +fragment Hidden: DelimitedComment | LineComment | WS; + +// SECTION: separatorsAndOperations + +RESERVED: '...'; +DOT: '.'; +COMMA: ','; +LPAREN: '(' -> pushMode(Inside); +RPAREN: ')'; +LSQUARE: '[' -> pushMode(Inside); +RSQUARE: ']'; +LCURL: '{' -> pushMode(DEFAULT_MODE); +/* + * When using another programming language (not Java) to generate a parser, + * please replace this code with the corresponding code of a programming language you are using. + */ +RCURL: '}' -> popMode; +MULT: '*'; +MOD: '%'; +DIV: '/'; +ADD: '+'; +SUB: '-'; +INCR: '++'; +DECR: '--'; +CONJ: '&&'; +DISJ: '||'; +EXCL_WS: '!' Hidden; +EXCL_NO_WS: '!'; +COLON: ':'; +SEMICOLON: ';'; +ASSIGNMENT: '='; +ADD_ASSIGNMENT: '+='; +SUB_ASSIGNMENT: '-='; +MULT_ASSIGNMENT: '*='; +DIV_ASSIGNMENT: '/='; +MOD_ASSIGNMENT: '%='; +ARROW: '->'; +DOUBLE_ARROW: '=>'; +RANGE: '..'; +COLONCOLON: '::'; +DOUBLE_SEMICOLON: ';;'; +HASH: '#'; +AT_NO_WS: '@'; +AT_POST_WS: '@' (Hidden | NL); +AT_PRE_WS: (Hidden | NL) '@' ; +AT_BOTH_WS: (Hidden | NL) '@' (Hidden | NL); +QUEST_WS: '?' Hidden; +QUEST_NO_WS: '?'; +LANGLE: '<'; +RANGLE: '>'; +LE: '<='; +GE: '>='; +EXCL_EQ: '!='; +EXCL_EQEQ: '!=='; +AS_SAFE: 'as?'; +EQEQ: '=='; +EQEQEQ: '==='; +SINGLE_QUOTE: '\''; +AMP: '&'; + +// SECTION: keywords + +RETURN_AT: 'return@' Identifier; +CONTINUE_AT: 'continue@' Identifier; +BREAK_AT: 'break@' Identifier; + +THIS_AT: 'this@' Identifier; +SUPER_AT: 'super@' Identifier; + +FILE: 'file'; +FIELD: 'field'; +PROPERTY: 'property'; +GET: 'get'; +SET: 'set'; +RECEIVER: 'receiver'; +PARAM: 'param'; +SETPARAM: 'setparam'; +DELEGATE: 'delegate'; + +PACKAGE: 'package'; +IMPORT: 'import'; +CLASS: 'class'; +INTERFACE: 'interface'; +FUN: 'fun'; +OBJECT: 'object'; +VAL: 'val'; +VAR: 'var'; +TYPE_ALIAS: 'typealias'; +CONSTRUCTOR: 'constructor'; +BY: 'by'; +COMPANION: 'companion'; +INIT: 'init'; +THIS: 'this'; +SUPER: 'super'; +TYPEOF: 'typeof'; +WHERE: 'where'; +IF: 'if'; +ELSE: 'else'; +WHEN: 'when'; +TRY: 'try'; +CATCH: 'catch'; +FINALLY: 'finally'; +FOR: 'for'; +DO: 'do'; +WHILE: 'while'; +THROW: 'throw'; +RETURN: 'return'; +CONTINUE: 'continue'; +BREAK: 'break'; +AS: 'as'; +IS: 'is'; +IN: 'in'; +NOT_IS: '!is' (Hidden | NL); +NOT_IN: '!in' (Hidden | NL); +OUT: 'out'; +DYNAMIC: 'dynamic'; + +// SECTION: lexicalModifiers + +PUBLIC: 'public'; +PRIVATE: 'private'; +PROTECTED: 'protected'; +INTERNAL: 'internal'; +ENUM: 'enum'; +SEALED: 'sealed'; +ANNOTATION: 'annotation'; +DATA: 'data'; +INNER: 'inner'; +VALUE: 'value'; +TAILREC: 'tailrec'; +OPERATOR: 'operator'; +INLINE: 'inline'; +INFIX: 'infix'; +EXTERNAL: 'external'; +SUSPEND: 'suspend'; +OVERRIDE: 'override'; +ABSTRACT: 'abstract'; +FINAL: 'final'; +OPEN: 'open'; +CONST: 'const'; +LATEINIT: 'lateinit'; +VARARG: 'vararg'; +NOINLINE: 'noinline'; +CROSSINLINE: 'crossinline'; +REIFIED: 'reified'; +EXPECT: 'expect'; +ACTUAL: 'actual'; + +// SECTION: literals + +fragment DecDigit: '0'..'9'; +fragment DecDigitNoZero: '1'..'9'; +fragment DecDigitOrSeparator: DecDigit | '_'; + +fragment DecDigits + : DecDigit DecDigitOrSeparator* DecDigit + | DecDigit + ; + +fragment DoubleExponent: [eE] [+-]? DecDigits; + +RealLiteral + : FloatLiteral + | DoubleLiteral + ; + +FloatLiteral + : DoubleLiteral [fF] + | DecDigits [fF] + ; + +DoubleLiteral + : DecDigits? '.' DecDigits DoubleExponent? + | DecDigits DoubleExponent + ; + +IntegerLiteral + : DecDigitNoZero DecDigitOrSeparator* DecDigit + | DecDigit + ; + +fragment HexDigit: [0-9a-fA-F]; +fragment HexDigitOrSeparator: HexDigit | '_'; + +HexLiteral + : '0' [xX] HexDigit HexDigitOrSeparator* HexDigit + | '0' [xX] HexDigit + ; + +fragment BinDigit: [01]; +fragment BinDigitOrSeparator: BinDigit | '_'; + +BinLiteral + : '0' [bB] BinDigit BinDigitOrSeparator* BinDigit + | '0' [bB] BinDigit + ; + +UnsignedLiteral + : (IntegerLiteral | HexLiteral | BinLiteral) [uU] [lL]? + ; + +LongLiteral + : (IntegerLiteral | HexLiteral | BinLiteral) [lL] + ; + +BooleanLiteral: 'true'| 'false'; + +NullLiteral: 'null'; + +CharacterLiteral + : '\'' (EscapeSeq | ~[\n\r'\\]) '\'' + ; + +// SECTION: lexicalIdentifiers + +fragment UnicodeDigit: UNICODE_CLASS_ND; + +Identifier + : (Letter | '_') (Letter | '_' | UnicodeDigit)* + | '`' ~([\r\n] | '`')+ '`' + ; + +IdentifierOrSoftKey + : Identifier + /* Soft keywords */ + | ABSTRACT + | ANNOTATION + | BY + | CATCH + | COMPANION + | CONSTRUCTOR + | CROSSINLINE + | DATA + | DYNAMIC + | ENUM + | EXTERNAL + | FINAL + | FINALLY + | IMPORT + | INFIX + | INIT + | INLINE + | INNER + | INTERNAL + | LATEINIT + | NOINLINE + | OPEN + | OPERATOR + | OUT + | OVERRIDE + | PRIVATE + | PROTECTED + | PUBLIC + | REIFIED + | SEALED + | TAILREC + | VARARG + | WHERE + | GET + | SET + | FIELD + | PROPERTY + | RECEIVER + | PARAM + | SETPARAM + | DELEGATE + | FILE + | EXPECT + | ACTUAL + | VALUE + /* Strong keywords */ + | CONST + | SUSPEND + ; + +FieldIdentifier + : '$' IdentifierOrSoftKey + ; + +fragment UniCharacterLiteral + : '\\' 'u' HexDigit HexDigit HexDigit HexDigit + ; + +fragment EscapedIdentifier + : '\\' ('t' | 'b' | 'r' | 'n' | '\'' | '"' | '\\' | '$') + ; + +fragment EscapeSeq + : UniCharacterLiteral + | EscapedIdentifier + ; + +// SECTION: characters + +fragment Letter + : UNICODE_CLASS_LU + | UNICODE_CLASS_LL + | UNICODE_CLASS_LT + | UNICODE_CLASS_LM + | UNICODE_CLASS_LO + ; + +// SECTION: strings + +QUOTE_OPEN: '"' -> pushMode(LineString); + +TRIPLE_QUOTE_OPEN: '"""' -> pushMode(MultiLineString); + +mode LineString; + +QUOTE_CLOSE + : '"' -> popMode + ; + +LineStrRef + : FieldIdentifier + ; + +LineStrText + : ~('\\' | '"' | '$')+ | '$' + ; + +LineStrEscapedChar + : EscapedIdentifier + | UniCharacterLiteral + ; + +LineStrExprStart + : '${' -> pushMode(DEFAULT_MODE) + ; + +mode MultiLineString; + +TRIPLE_QUOTE_CLOSE + : MultiLineStringQuote? '"""' -> popMode + ; + +MultiLineStringQuote + : '"'+ + ; + +MultiLineStrRef + : FieldIdentifier + ; + +MultiLineStrText + : ~('"' | '$')+ | '$' + ; + +MultiLineStrExprStart + : '${' -> pushMode(DEFAULT_MODE) + ; + +// SECTION: inside + +mode Inside; + +Inside_RPAREN: RPAREN -> popMode, type(RPAREN); +Inside_RSQUARE: RSQUARE -> popMode, type(RSQUARE); +Inside_LPAREN: LPAREN -> pushMode(Inside), type(LPAREN); +Inside_LSQUARE: LSQUARE -> pushMode(Inside), type(LSQUARE); +Inside_LCURL: LCURL -> pushMode(DEFAULT_MODE), type(LCURL); +Inside_RCURL: RCURL -> popMode, type(RCURL); + +Inside_DOT: DOT -> type(DOT); +Inside_COMMA: COMMA -> type(COMMA); +Inside_MULT: MULT -> type(MULT); +Inside_MOD: MOD -> type(MOD); +Inside_DIV: DIV -> type(DIV); +Inside_ADD: ADD -> type(ADD); +Inside_SUB: SUB -> type(SUB); +Inside_INCR: INCR -> type(INCR); +Inside_DECR: DECR -> type(DECR); +Inside_CONJ: CONJ -> type(CONJ); +Inside_DISJ: DISJ -> type(DISJ); +Inside_EXCL_WS: '!' (Hidden|NL) -> type(EXCL_WS); +Inside_EXCL_NO_WS: EXCL_NO_WS -> type(EXCL_NO_WS); +Inside_COLON: COLON -> type(COLON); +Inside_SEMICOLON: SEMICOLON -> type(SEMICOLON); +Inside_ASSIGNMENT: ASSIGNMENT -> type(ASSIGNMENT); +Inside_ADD_ASSIGNMENT: ADD_ASSIGNMENT -> type(ADD_ASSIGNMENT); +Inside_SUB_ASSIGNMENT: SUB_ASSIGNMENT -> type(SUB_ASSIGNMENT); +Inside_MULT_ASSIGNMENT: MULT_ASSIGNMENT -> type(MULT_ASSIGNMENT); +Inside_DIV_ASSIGNMENT: DIV_ASSIGNMENT -> type(DIV_ASSIGNMENT); +Inside_MOD_ASSIGNMENT: MOD_ASSIGNMENT -> type(MOD_ASSIGNMENT); +Inside_ARROW: ARROW -> type(ARROW); +Inside_DOUBLE_ARROW: DOUBLE_ARROW -> type(DOUBLE_ARROW); +Inside_RANGE: RANGE -> type(RANGE); +Inside_RESERVED: RESERVED -> type(RESERVED); +Inside_COLONCOLON: COLONCOLON -> type(COLONCOLON); +Inside_DOUBLE_SEMICOLON: DOUBLE_SEMICOLON -> type(DOUBLE_SEMICOLON); +Inside_HASH: HASH -> type(HASH); +Inside_AT_NO_WS: AT_NO_WS -> type(AT_NO_WS); +Inside_AT_POST_WS: AT_POST_WS -> type(AT_POST_WS); +Inside_AT_PRE_WS: AT_PRE_WS -> type(AT_PRE_WS); +Inside_AT_BOTH_WS: AT_BOTH_WS -> type(AT_BOTH_WS); +Inside_QUEST_WS: '?' (Hidden | NL) -> type(QUEST_WS); +Inside_QUEST_NO_WS: QUEST_NO_WS -> type(QUEST_NO_WS); +Inside_LANGLE: LANGLE -> type(LANGLE); +Inside_RANGLE: RANGLE -> type(RANGLE); +Inside_LE: LE -> type(LE); +Inside_GE: GE -> type(GE); +Inside_EXCL_EQ: EXCL_EQ -> type(EXCL_EQ); +Inside_EXCL_EQEQ: EXCL_EQEQ -> type(EXCL_EQEQ); +Inside_IS: IS -> type(IS); +Inside_NOT_IS: NOT_IS -> type(NOT_IS); +Inside_NOT_IN: NOT_IN -> type(NOT_IN); +Inside_AS: AS -> type(AS); +Inside_AS_SAFE: AS_SAFE -> type(AS_SAFE); +Inside_EQEQ: EQEQ -> type(EQEQ); +Inside_EQEQEQ: EQEQEQ -> type(EQEQEQ); +Inside_SINGLE_QUOTE: SINGLE_QUOTE -> type(SINGLE_QUOTE); +Inside_AMP: AMP -> type(AMP); +Inside_QUOTE_OPEN: QUOTE_OPEN -> pushMode(LineString), type(QUOTE_OPEN); +Inside_TRIPLE_QUOTE_OPEN: TRIPLE_QUOTE_OPEN -> pushMode(MultiLineString), type(TRIPLE_QUOTE_OPEN); + +Inside_VAL: VAL -> type(VAL); +Inside_VAR: VAR -> type(VAR); +Inside_FUN: FUN -> type(FUN); +Inside_OBJECT: OBJECT -> type(OBJECT); +Inside_SUPER: SUPER -> type(SUPER); +Inside_IN: IN -> type(IN); +Inside_OUT: OUT -> type(OUT); +Inside_FIELD: FIELD -> type(FIELD); +Inside_FILE: FILE -> type(FILE); +Inside_PROPERTY: PROPERTY -> type(PROPERTY); +Inside_GET: GET -> type(GET); +Inside_SET: SET -> type(SET); +Inside_RECEIVER: RECEIVER -> type(RECEIVER); +Inside_PARAM: PARAM -> type(PARAM); +Inside_SETPARAM: SETPARAM -> type(SETPARAM); +Inside_DELEGATE: DELEGATE -> type(DELEGATE); +Inside_THROW: THROW -> type(THROW); +Inside_RETURN: RETURN -> type(RETURN); +Inside_CONTINUE: CONTINUE -> type(CONTINUE); +Inside_BREAK: BREAK -> type(BREAK); +Inside_RETURN_AT: RETURN_AT -> type(RETURN_AT); +Inside_CONTINUE_AT: CONTINUE_AT -> type(CONTINUE_AT); +Inside_BREAK_AT: BREAK_AT -> type(BREAK_AT); +Inside_IF: IF -> type(IF); +Inside_ELSE: ELSE -> type(ELSE); +Inside_WHEN: WHEN -> type(WHEN); +Inside_TRY: TRY -> type(TRY); +Inside_CATCH: CATCH -> type(CATCH); +Inside_FINALLY: FINALLY -> type(FINALLY); +Inside_FOR: FOR -> type(FOR); +Inside_DO: DO -> type(DO); +Inside_WHILE: WHILE -> type(WHILE); + +Inside_PUBLIC: PUBLIC -> type(PUBLIC); +Inside_PRIVATE: PRIVATE -> type(PRIVATE); +Inside_PROTECTED: PROTECTED -> type(PROTECTED); +Inside_INTERNAL: INTERNAL -> type(INTERNAL); +Inside_ENUM: ENUM -> type(ENUM); +Inside_SEALED: SEALED -> type(SEALED); +Inside_ANNOTATION: ANNOTATION -> type(ANNOTATION); +Inside_DATA: DATA -> type(DATA); +Inside_INNER: INNER -> type(INNER); +Inside_VALUE: VALUE -> type(VALUE); +Inside_TAILREC: TAILREC -> type(TAILREC); +Inside_OPERATOR: OPERATOR -> type(OPERATOR); +Inside_INLINE: INLINE -> type(INLINE); +Inside_INFIX: INFIX -> type(INFIX); +Inside_EXTERNAL: EXTERNAL -> type(EXTERNAL); +Inside_SUSPEND: SUSPEND -> type(SUSPEND); +Inside_OVERRIDE: OVERRIDE -> type(OVERRIDE); +Inside_ABSTRACT: ABSTRACT -> type(ABSTRACT); +Inside_FINAL: FINAL -> type(FINAL); +Inside_OPEN: OPEN -> type(OPEN); +Inside_CONST: CONST -> type(CONST); +Inside_LATEINIT: LATEINIT -> type(LATEINIT); +Inside_VARARG: VARARG -> type(VARARG); +Inside_NOINLINE: NOINLINE -> type(NOINLINE); +Inside_CROSSINLINE: CROSSINLINE -> type(CROSSINLINE); +Inside_REIFIED: REIFIED -> type(REIFIED); +Inside_EXPECT: EXPECT -> type(EXPECT); +Inside_ACTUAL: ACTUAL -> type(ACTUAL); + +Inside_BooleanLiteral: BooleanLiteral -> type(BooleanLiteral); +Inside_IntegerLiteral: IntegerLiteral -> type(IntegerLiteral); +Inside_HexLiteral: HexLiteral -> type(HexLiteral); +Inside_BinLiteral: BinLiteral -> type(BinLiteral); +Inside_CharacterLiteral: CharacterLiteral -> type(CharacterLiteral); +Inside_RealLiteral: RealLiteral -> type(RealLiteral); +Inside_NullLiteral: NullLiteral -> type(NullLiteral); +Inside_LongLiteral: LongLiteral -> type(LongLiteral); +Inside_UnsignedLiteral: UnsignedLiteral -> type(UnsignedLiteral); + +Inside_Identifier: Identifier -> type(Identifier); +Inside_Comment: (LineComment | DelimitedComment) -> channel(HIDDEN); +Inside_WS: WS -> channel(HIDDEN); +Inside_NL: NL -> channel(HIDDEN); + +mode DEFAULT_MODE; + +ErrorCharacter: .; diff --git a/lib/archer/kotlin_parser/KotlinLexer.interp b/lib/archer/kotlin_parser/KotlinLexer.interp new file mode 100644 index 0000000..815bafd --- /dev/null +++ b/lib/archer/kotlin_parser/KotlinLexer.interp @@ -0,0 +1,678 @@ +token literal names: +null +null +null +null +null +null +'...' +'.' +',' +'(' +')' +'[' +']' +'{' +'}' +'*' +'%' +'/' +'+' +'-' +'++' +'--' +'&&' +'||' +null +'!' +':' +';' +'=' +'+=' +'-=' +'*=' +'/=' +'%=' +'->' +'=>' +'..' +'::' +';;' +'#' +'@' +null +null +null +null +'?' +'<' +'>' +'<=' +'>=' +'!=' +'!==' +'as?' +'==' +'===' +'\'' +'&' +null +null +null +null +null +'file' +'field' +'property' +'get' +'set' +'receiver' +'param' +'setparam' +'delegate' +'package' +'import' +'class' +'interface' +'fun' +'object' +'val' +'var' +'typealias' +'constructor' +'by' +'companion' +'init' +'this' +'super' +'typeof' +'where' +'if' +'else' +'when' +'try' +'catch' +'finally' +'for' +'do' +'while' +'throw' +'return' +'continue' +'break' +'as' +'is' +'in' +null +null +'out' +'dynamic' +'public' +'private' +'protected' +'internal' +'enum' +'sealed' +'annotation' +'data' +'inner' +'value' +'tailrec' +'operator' +'inline' +'infix' +'external' +'suspend' +'override' +'abstract' +'final' +'open' +'const' +'lateinit' +'vararg' +'noinline' +'crossinline' +'reified' +'expect' +'actual' +null +null +null +null +null +null +null +null +null +'null' +null +null +null +null +null +'"""' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +ShebangLine +DelimitedComment +LineComment +WS +NL +RESERVED +DOT +COMMA +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURL +RCURL +MULT +MOD +DIV +ADD +SUB +INCR +DECR +CONJ +DISJ +EXCL_WS +EXCL_NO_WS +COLON +SEMICOLON +ASSIGNMENT +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MULT_ASSIGNMENT +DIV_ASSIGNMENT +MOD_ASSIGNMENT +ARROW +DOUBLE_ARROW +RANGE +COLONCOLON +DOUBLE_SEMICOLON +HASH +AT_NO_WS +AT_POST_WS +AT_PRE_WS +AT_BOTH_WS +QUEST_WS +QUEST_NO_WS +LANGLE +RANGLE +LE +GE +EXCL_EQ +EXCL_EQEQ +AS_SAFE +EQEQ +EQEQEQ +SINGLE_QUOTE +AMP +RETURN_AT +CONTINUE_AT +BREAK_AT +THIS_AT +SUPER_AT +FILE +FIELD +PROPERTY +GET +SET +RECEIVER +PARAM +SETPARAM +DELEGATE +PACKAGE +IMPORT +CLASS +INTERFACE +FUN +OBJECT +VAL +VAR +TYPE_ALIAS +CONSTRUCTOR +BY +COMPANION +INIT +THIS +SUPER +TYPEOF +WHERE +IF +ELSE +WHEN +TRY +CATCH +FINALLY +FOR +DO +WHILE +THROW +RETURN +CONTINUE +BREAK +AS +IS +IN +NOT_IS +NOT_IN +OUT +DYNAMIC +PUBLIC +PRIVATE +PROTECTED +INTERNAL +ENUM +SEALED +ANNOTATION +DATA +INNER +VALUE +TAILREC +OPERATOR +INLINE +INFIX +EXTERNAL +SUSPEND +OVERRIDE +ABSTRACT +FINAL +OPEN +CONST +LATEINIT +VARARG +NOINLINE +CROSSINLINE +REIFIED +EXPECT +ACTUAL +RealLiteral +FloatLiteral +DoubleLiteral +IntegerLiteral +HexLiteral +BinLiteral +UnsignedLiteral +LongLiteral +BooleanLiteral +NullLiteral +CharacterLiteral +Identifier +IdentifierOrSoftKey +FieldIdentifier +QUOTE_OPEN +TRIPLE_QUOTE_OPEN +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL +QUOTE_CLOSE +LineStrRef +LineStrText +LineStrEscapedChar +LineStrExprStart +TRIPLE_QUOTE_CLOSE +MultiLineStringQuote +MultiLineStrRef +MultiLineStrText +MultiLineStrExprStart +Inside_Comment +Inside_WS +Inside_NL +ErrorCharacter + +rule names: +ShebangLine +DelimitedComment +LineComment +WS +NL +Hidden +RESERVED +DOT +COMMA +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURL +RCURL +MULT +MOD +DIV +ADD +SUB +INCR +DECR +CONJ +DISJ +EXCL_WS +EXCL_NO_WS +COLON +SEMICOLON +ASSIGNMENT +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MULT_ASSIGNMENT +DIV_ASSIGNMENT +MOD_ASSIGNMENT +ARROW +DOUBLE_ARROW +RANGE +COLONCOLON +DOUBLE_SEMICOLON +HASH +AT_NO_WS +AT_POST_WS +AT_PRE_WS +AT_BOTH_WS +QUEST_WS +QUEST_NO_WS +LANGLE +RANGLE +LE +GE +EXCL_EQ +EXCL_EQEQ +AS_SAFE +EQEQ +EQEQEQ +SINGLE_QUOTE +AMP +RETURN_AT +CONTINUE_AT +BREAK_AT +THIS_AT +SUPER_AT +FILE +FIELD +PROPERTY +GET +SET +RECEIVER +PARAM +SETPARAM +DELEGATE +PACKAGE +IMPORT +CLASS +INTERFACE +FUN +OBJECT +VAL +VAR +TYPE_ALIAS +CONSTRUCTOR +BY +COMPANION +INIT +THIS +SUPER +TYPEOF +WHERE +IF +ELSE +WHEN +TRY +CATCH +FINALLY +FOR +DO +WHILE +THROW +RETURN +CONTINUE +BREAK +AS +IS +IN +NOT_IS +NOT_IN +OUT +DYNAMIC +PUBLIC +PRIVATE +PROTECTED +INTERNAL +ENUM +SEALED +ANNOTATION +DATA +INNER +VALUE +TAILREC +OPERATOR +INLINE +INFIX +EXTERNAL +SUSPEND +OVERRIDE +ABSTRACT +FINAL +OPEN +CONST +LATEINIT +VARARG +NOINLINE +CROSSINLINE +REIFIED +EXPECT +ACTUAL +DecDigit +DecDigitNoZero +DecDigitOrSeparator +DecDigits +DoubleExponent +RealLiteral +FloatLiteral +DoubleLiteral +IntegerLiteral +HexDigit +HexDigitOrSeparator +HexLiteral +BinDigit +BinDigitOrSeparator +BinLiteral +UnsignedLiteral +LongLiteral +BooleanLiteral +NullLiteral +CharacterLiteral +UnicodeDigit +Identifier +IdentifierOrSoftKey +FieldIdentifier +UniCharacterLiteral +EscapedIdentifier +EscapeSeq +Letter +QUOTE_OPEN +TRIPLE_QUOTE_OPEN +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL +QUOTE_CLOSE +LineStrRef +LineStrText +LineStrEscapedChar +LineStrExprStart +TRIPLE_QUOTE_CLOSE +MultiLineStringQuote +MultiLineStrRef +MultiLineStrText +MultiLineStrExprStart +Inside_RPAREN +Inside_RSQUARE +Inside_LPAREN +Inside_LSQUARE +Inside_LCURL +Inside_RCURL +Inside_DOT +Inside_COMMA +Inside_MULT +Inside_MOD +Inside_DIV +Inside_ADD +Inside_SUB +Inside_INCR +Inside_DECR +Inside_CONJ +Inside_DISJ +Inside_EXCL_WS +Inside_EXCL_NO_WS +Inside_COLON +Inside_SEMICOLON +Inside_ASSIGNMENT +Inside_ADD_ASSIGNMENT +Inside_SUB_ASSIGNMENT +Inside_MULT_ASSIGNMENT +Inside_DIV_ASSIGNMENT +Inside_MOD_ASSIGNMENT +Inside_ARROW +Inside_DOUBLE_ARROW +Inside_RANGE +Inside_RESERVED +Inside_COLONCOLON +Inside_DOUBLE_SEMICOLON +Inside_HASH +Inside_AT_NO_WS +Inside_AT_POST_WS +Inside_AT_PRE_WS +Inside_AT_BOTH_WS +Inside_QUEST_WS +Inside_QUEST_NO_WS +Inside_LANGLE +Inside_RANGLE +Inside_LE +Inside_GE +Inside_EXCL_EQ +Inside_EXCL_EQEQ +Inside_IS +Inside_NOT_IS +Inside_NOT_IN +Inside_AS +Inside_AS_SAFE +Inside_EQEQ +Inside_EQEQEQ +Inside_SINGLE_QUOTE +Inside_AMP +Inside_QUOTE_OPEN +Inside_TRIPLE_QUOTE_OPEN +Inside_VAL +Inside_VAR +Inside_FUN +Inside_OBJECT +Inside_SUPER +Inside_IN +Inside_OUT +Inside_FIELD +Inside_FILE +Inside_PROPERTY +Inside_GET +Inside_SET +Inside_RECEIVER +Inside_PARAM +Inside_SETPARAM +Inside_DELEGATE +Inside_THROW +Inside_RETURN +Inside_CONTINUE +Inside_BREAK +Inside_RETURN_AT +Inside_CONTINUE_AT +Inside_BREAK_AT +Inside_IF +Inside_ELSE +Inside_WHEN +Inside_TRY +Inside_CATCH +Inside_FINALLY +Inside_FOR +Inside_DO +Inside_WHILE +Inside_PUBLIC +Inside_PRIVATE +Inside_PROTECTED +Inside_INTERNAL +Inside_ENUM +Inside_SEALED +Inside_ANNOTATION +Inside_DATA +Inside_INNER +Inside_VALUE +Inside_TAILREC +Inside_OPERATOR +Inside_INLINE +Inside_INFIX +Inside_EXTERNAL +Inside_SUSPEND +Inside_OVERRIDE +Inside_ABSTRACT +Inside_FINAL +Inside_OPEN +Inside_CONST +Inside_LATEINIT +Inside_VARARG +Inside_NOINLINE +Inside_CROSSINLINE +Inside_REIFIED +Inside_EXPECT +Inside_ACTUAL +Inside_BooleanLiteral +Inside_IntegerLiteral +Inside_HexLiteral +Inside_BinLiteral +Inside_CharacterLiteral +Inside_RealLiteral +Inside_NullLiteral +Inside_LongLiteral +Inside_UnsignedLiteral +Inside_Identifier +Inside_Comment +Inside_WS +Inside_NL +ErrorCharacter + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE +LineString +MultiLineString +Inside + +atn: +[4, 0, 172, 2239, 6, -1, 6, -1, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 637, 8, 0, 10, 0, 12, 0, 640, 9, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 647, 8, 1, 10, 1, 12, 1, 650, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 661, 8, 2, 10, 2, 12, 2, 664, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 3, 4, 675, 8, 4, 3, 4, 677, 8, 4, 1, 5, 1, 5, 1, 5, 3, 5, 682, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 3, 41, 782, 8, 41, 1, 42, 1, 42, 3, 42, 786, 8, 42, 1, 42, 1, 42, 1, 43, 1, 43, 3, 43, 792, 8, 43, 1, 43, 1, 43, 1, 43, 3, 43, 797, 8, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1146, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1154, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 3, 138, 1389, 8, 138, 1, 139, 1, 139, 5, 139, 1393, 8, 139, 10, 139, 12, 139, 1396, 9, 139, 1, 139, 1, 139, 1, 139, 3, 139, 1401, 8, 139, 1, 140, 1, 140, 3, 140, 1405, 8, 140, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 1411, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 1419, 8, 142, 1, 143, 3, 143, 1422, 8, 143, 1, 143, 1, 143, 1, 143, 3, 143, 1427, 8, 143, 1, 143, 1, 143, 1, 143, 3, 143, 1432, 8, 143, 1, 144, 1, 144, 5, 144, 1436, 8, 144, 10, 144, 12, 144, 1439, 9, 144, 1, 144, 1, 144, 1, 144, 3, 144, 1444, 8, 144, 1, 145, 1, 145, 1, 146, 1, 146, 3, 146, 1450, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 5, 147, 1456, 8, 147, 10, 147, 12, 147, 1459, 9, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 1466, 8, 147, 1, 148, 1, 148, 1, 149, 1, 149, 3, 149, 1472, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 1478, 8, 150, 10, 150, 12, 150, 1481, 9, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 1488, 8, 150, 1, 151, 1, 151, 1, 151, 3, 151, 1493, 8, 151, 1, 151, 1, 151, 3, 151, 1497, 8, 151, 1, 152, 1, 152, 1, 152, 3, 152, 1502, 8, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 1515, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 3, 155, 1525, 8, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 3, 157, 1533, 8, 157, 1, 157, 1, 157, 1, 157, 5, 157, 1538, 8, 157, 10, 157, 12, 157, 1541, 9, 157, 1, 157, 1, 157, 4, 157, 1545, 8, 157, 11, 157, 12, 157, 1546, 1, 157, 3, 157, 1550, 8, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 1600, 8, 158, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 3, 162, 1617, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 1624, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 171, 1, 171, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 175, 4, 175, 1657, 8, 175, 11, 175, 12, 175, 1658, 1, 175, 3, 175, 1662, 8, 175, 1, 176, 1, 176, 3, 176, 1666, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 3, 178, 1674, 8, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 4, 179, 1683, 8, 179, 11, 179, 12, 179, 1684, 1, 180, 1, 180, 1, 181, 4, 181, 1690, 8, 181, 11, 181, 12, 181, 1691, 1, 181, 3, 181, 1695, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 3, 200, 1779, 8, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 3, 221, 1866, 8, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 3, 310, 2226, 8, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 648, 0, 314, 4, 1, 6, 2, 8, 3, 10, 4, 12, 5, 14, 0, 16, 6, 18, 7, 20, 8, 22, 9, 24, 10, 26, 11, 28, 12, 30, 13, 32, 14, 34, 15, 36, 16, 38, 17, 40, 18, 42, 19, 44, 20, 46, 21, 48, 22, 50, 23, 52, 24, 54, 25, 56, 26, 58, 27, 60, 28, 62, 29, 64, 30, 66, 31, 68, 32, 70, 33, 72, 34, 74, 35, 76, 36, 78, 37, 80, 38, 82, 39, 84, 40, 86, 41, 88, 42, 90, 43, 92, 44, 94, 45, 96, 46, 98, 47, 100, 48, 102, 49, 104, 50, 106, 51, 108, 52, 110, 53, 112, 54, 114, 55, 116, 56, 118, 57, 120, 58, 122, 59, 124, 60, 126, 61, 128, 62, 130, 63, 132, 64, 134, 65, 136, 66, 138, 67, 140, 68, 142, 69, 144, 70, 146, 71, 148, 72, 150, 73, 152, 74, 154, 75, 156, 76, 158, 77, 160, 78, 162, 79, 164, 80, 166, 81, 168, 82, 170, 83, 172, 84, 174, 85, 176, 86, 178, 87, 180, 88, 182, 89, 184, 90, 186, 91, 188, 92, 190, 93, 192, 94, 194, 95, 196, 96, 198, 97, 200, 98, 202, 99, 204, 100, 206, 101, 208, 102, 210, 103, 212, 104, 214, 105, 216, 106, 218, 107, 220, 108, 222, 109, 224, 110, 226, 111, 228, 112, 230, 113, 232, 114, 234, 115, 236, 116, 238, 117, 240, 118, 242, 119, 244, 120, 246, 121, 248, 122, 250, 123, 252, 124, 254, 125, 256, 126, 258, 127, 260, 128, 262, 129, 264, 130, 266, 131, 268, 132, 270, 133, 272, 134, 274, 135, 276, 0, 278, 0, 280, 0, 282, 0, 284, 0, 286, 136, 288, 137, 290, 138, 292, 139, 294, 0, 296, 0, 298, 140, 300, 0, 302, 0, 304, 141, 306, 142, 308, 143, 310, 144, 312, 145, 314, 146, 316, 0, 318, 147, 320, 148, 322, 149, 324, 0, 326, 0, 328, 0, 330, 0, 332, 150, 334, 151, 336, 152, 338, 153, 340, 154, 342, 155, 344, 156, 346, 157, 348, 158, 350, 159, 352, 160, 354, 161, 356, 162, 358, 163, 360, 164, 362, 165, 364, 166, 366, 167, 368, 168, 370, 0, 372, 0, 374, 0, 376, 0, 378, 0, 380, 0, 382, 0, 384, 0, 386, 0, 388, 0, 390, 0, 392, 0, 394, 0, 396, 0, 398, 0, 400, 0, 402, 0, 404, 0, 406, 0, 408, 0, 410, 0, 412, 0, 414, 0, 416, 0, 418, 0, 420, 0, 422, 0, 424, 0, 426, 0, 428, 0, 430, 0, 432, 0, 434, 0, 436, 0, 438, 0, 440, 0, 442, 0, 444, 0, 446, 0, 448, 0, 450, 0, 452, 0, 454, 0, 456, 0, 458, 0, 460, 0, 462, 0, 464, 0, 466, 0, 468, 0, 470, 0, 472, 0, 474, 0, 476, 0, 478, 0, 480, 0, 482, 0, 484, 0, 486, 0, 488, 0, 490, 0, 492, 0, 494, 0, 496, 0, 498, 0, 500, 0, 502, 0, 504, 0, 506, 0, 508, 0, 510, 0, 512, 0, 514, 0, 516, 0, 518, 0, 520, 0, 522, 0, 524, 0, 526, 0, 528, 0, 530, 0, 532, 0, 534, 0, 536, 0, 538, 0, 540, 0, 542, 0, 544, 0, 546, 0, 548, 0, 550, 0, 552, 0, 554, 0, 556, 0, 558, 0, 560, 0, 562, 0, 564, 0, 566, 0, 568, 0, 570, 0, 572, 0, 574, 0, 576, 0, 578, 0, 580, 0, 582, 0, 584, 0, 586, 0, 588, 0, 590, 0, 592, 0, 594, 0, 596, 0, 598, 0, 600, 0, 602, 0, 604, 0, 606, 0, 608, 0, 610, 0, 612, 0, 614, 0, 616, 0, 618, 0, 620, 0, 622, 0, 624, 169, 626, 170, 628, 171, 630, 172, 4, 0, 1, 2, 3, 23, 2, 0, 10, 10, 13, 13, 3, 0, 9, 9, 12, 12, 32, 32, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 70, 70, 102, 102, 3, 0, 48, 57, 65, 70, 97, 102, 2, 0, 88, 88, 120, 120, 1, 0, 48, 49, 2, 0, 66, 66, 98, 98, 2, 0, 85, 85, 117, 117, 2, 0, 76, 76, 108, 108, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 3, 0, 10, 10, 13, 13, 96, 96, 8, 0, 34, 34, 36, 36, 39, 39, 92, 92, 98, 98, 110, 110, 114, 114, 116, 116, 582, 0, 97, 122, 181, 181, 223, 246, 248, 255, 257, 257, 259, 259, 261, 261, 263, 263, 265, 265, 267, 267, 269, 269, 271, 271, 273, 273, 275, 275, 277, 277, 279, 279, 281, 281, 283, 283, 285, 285, 287, 287, 289, 289, 291, 291, 293, 293, 295, 295, 297, 297, 299, 299, 301, 301, 303, 303, 305, 305, 307, 307, 309, 309, 311, 312, 314, 314, 316, 316, 318, 318, 320, 320, 322, 322, 324, 324, 326, 326, 328, 329, 331, 331, 333, 333, 335, 335, 337, 337, 339, 339, 341, 341, 343, 343, 345, 345, 347, 347, 349, 349, 351, 351, 353, 353, 355, 355, 357, 357, 359, 359, 361, 361, 363, 363, 365, 365, 367, 367, 369, 369, 371, 371, 373, 373, 375, 375, 378, 378, 380, 380, 382, 384, 387, 387, 389, 389, 392, 392, 396, 397, 402, 402, 405, 405, 409, 411, 414, 414, 417, 417, 419, 419, 421, 421, 424, 424, 426, 427, 429, 429, 432, 432, 436, 436, 438, 438, 441, 442, 445, 447, 454, 454, 457, 457, 460, 460, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 477, 479, 479, 481, 481, 483, 483, 485, 485, 487, 487, 489, 489, 491, 491, 493, 493, 495, 496, 499, 499, 501, 501, 505, 505, 507, 507, 509, 509, 511, 511, 513, 513, 515, 515, 517, 517, 519, 519, 521, 521, 523, 523, 525, 525, 527, 527, 529, 529, 531, 531, 533, 533, 535, 535, 537, 537, 539, 539, 541, 541, 543, 543, 545, 545, 547, 547, 549, 549, 551, 551, 553, 553, 555, 555, 557, 557, 559, 559, 561, 561, 563, 569, 572, 572, 575, 576, 578, 578, 583, 583, 585, 585, 587, 587, 589, 589, 591, 659, 661, 687, 881, 881, 883, 883, 887, 887, 891, 893, 912, 912, 940, 974, 976, 977, 981, 983, 985, 985, 987, 987, 989, 989, 991, 991, 993, 993, 995, 995, 997, 997, 999, 999, 1001, 1001, 1003, 1003, 1005, 1005, 1007, 1011, 1013, 1013, 1016, 1016, 1019, 1020, 1072, 1119, 1121, 1121, 1123, 1123, 1125, 1125, 1127, 1127, 1129, 1129, 1131, 1131, 1133, 1133, 1135, 1135, 1137, 1137, 1139, 1139, 1141, 1141, 1143, 1143, 1145, 1145, 1147, 1147, 1149, 1149, 1151, 1151, 1153, 1153, 1163, 1163, 1165, 1165, 1167, 1167, 1169, 1169, 1171, 1171, 1173, 1173, 1175, 1175, 1177, 1177, 1179, 1179, 1181, 1181, 1183, 1183, 1185, 1185, 1187, 1187, 1189, 1189, 1191, 1191, 1193, 1193, 1195, 1195, 1197, 1197, 1199, 1199, 1201, 1201, 1203, 1203, 1205, 1205, 1207, 1207, 1209, 1209, 1211, 1211, 1213, 1213, 1215, 1215, 1218, 1218, 1220, 1220, 1222, 1222, 1224, 1224, 1226, 1226, 1228, 1228, 1230, 1231, 1233, 1233, 1235, 1235, 1237, 1237, 1239, 1239, 1241, 1241, 1243, 1243, 1245, 1245, 1247, 1247, 1249, 1249, 1251, 1251, 1253, 1253, 1255, 1255, 1257, 1257, 1259, 1259, 1261, 1261, 1263, 1263, 1265, 1265, 1267, 1267, 1269, 1269, 1271, 1271, 1273, 1273, 1275, 1275, 1277, 1277, 1279, 1279, 1281, 1281, 1283, 1283, 1285, 1285, 1287, 1287, 1289, 1289, 1291, 1291, 1293, 1293, 1295, 1295, 1297, 1297, 1299, 1299, 1301, 1301, 1303, 1303, 1305, 1305, 1307, 1307, 1309, 1309, 1311, 1311, 1313, 1313, 1315, 1315, 1317, 1317, 1319, 1319, 1377, 1415, 7424, 7467, 7531, 7543, 7545, 7578, 7681, 7681, 7683, 7683, 7685, 7685, 7687, 7687, 7689, 7689, 7691, 7691, 7693, 7693, 7695, 7695, 7697, 7697, 7699, 7699, 7701, 7701, 7703, 7703, 7705, 7705, 7707, 7707, 7709, 7709, 7711, 7711, 7713, 7713, 7715, 7715, 7717, 7717, 7719, 7719, 7721, 7721, 7723, 7723, 7725, 7725, 7727, 7727, 7729, 7729, 7731, 7731, 7733, 7733, 7735, 7735, 7737, 7737, 7739, 7739, 7741, 7741, 7743, 7743, 7745, 7745, 7747, 7747, 7749, 7749, 7751, 7751, 7753, 7753, 7755, 7755, 7757, 7757, 7759, 7759, 7761, 7761, 7763, 7763, 7765, 7765, 7767, 7767, 7769, 7769, 7771, 7771, 7773, 7773, 7775, 7775, 7777, 7777, 7779, 7779, 7781, 7781, 7783, 7783, 7785, 7785, 7787, 7787, 7789, 7789, 7791, 7791, 7793, 7793, 7795, 7795, 7797, 7797, 7799, 7799, 7801, 7801, 7803, 7803, 7805, 7805, 7807, 7807, 7809, 7809, 7811, 7811, 7813, 7813, 7815, 7815, 7817, 7817, 7819, 7819, 7821, 7821, 7823, 7823, 7825, 7825, 7827, 7827, 7829, 7837, 7839, 7839, 7841, 7841, 7843, 7843, 7845, 7845, 7847, 7847, 7849, 7849, 7851, 7851, 7853, 7853, 7855, 7855, 7857, 7857, 7859, 7859, 7861, 7861, 7863, 7863, 7865, 7865, 7867, 7867, 7869, 7869, 7871, 7871, 7873, 7873, 7875, 7875, 7877, 7877, 7879, 7879, 7881, 7881, 7883, 7883, 7885, 7885, 7887, 7887, 7889, 7889, 7891, 7891, 7893, 7893, 7895, 7895, 7897, 7897, 7899, 7899, 7901, 7901, 7903, 7903, 7905, 7905, 7907, 7907, 7909, 7909, 7911, 7911, 7913, 7913, 7915, 7915, 7917, 7917, 7919, 7919, 7921, 7921, 7923, 7923, 7925, 7925, 7927, 7927, 7929, 7929, 7931, 7931, 7933, 7933, 7935, 7943, 7952, 7957, 7968, 7975, 7984, 7991, 8000, 8005, 8016, 8023, 8032, 8039, 8048, 8061, 8064, 8071, 8080, 8087, 8096, 8103, 8112, 8116, 8118, 8119, 8126, 8126, 8130, 8132, 8134, 8135, 8144, 8147, 8150, 8151, 8160, 8167, 8178, 8180, 8182, 8183, 8458, 8458, 8462, 8463, 8467, 8467, 8495, 8495, 8500, 8500, 8505, 8505, 8508, 8509, 8518, 8521, 8526, 8526, 8580, 8580, 11312, 11358, 11361, 11361, 11365, 11366, 11368, 11368, 11370, 11370, 11372, 11372, 11377, 11377, 11379, 11380, 11382, 11387, 11393, 11393, 11395, 11395, 11397, 11397, 11399, 11399, 11401, 11401, 11403, 11403, 11405, 11405, 11407, 11407, 11409, 11409, 11411, 11411, 11413, 11413, 11415, 11415, 11417, 11417, 11419, 11419, 11421, 11421, 11423, 11423, 11425, 11425, 11427, 11427, 11429, 11429, 11431, 11431, 11433, 11433, 11435, 11435, 11437, 11437, 11439, 11439, 11441, 11441, 11443, 11443, 11445, 11445, 11447, 11447, 11449, 11449, 11451, 11451, 11453, 11453, 11455, 11455, 11457, 11457, 11459, 11459, 11461, 11461, 11463, 11463, 11465, 11465, 11467, 11467, 11469, 11469, 11471, 11471, 11473, 11473, 11475, 11475, 11477, 11477, 11479, 11479, 11481, 11481, 11483, 11483, 11485, 11485, 11487, 11487, 11489, 11489, 11491, 11492, 11500, 11500, 11502, 11502, 11507, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 42561, 42561, 42563, 42563, 42565, 42565, 42567, 42567, 42569, 42569, 42571, 42571, 42573, 42573, 42575, 42575, 42577, 42577, 42579, 42579, 42581, 42581, 42583, 42583, 42585, 42585, 42587, 42587, 42589, 42589, 42591, 42591, 42593, 42593, 42595, 42595, 42597, 42597, 42599, 42599, 42601, 42601, 42603, 42603, 42605, 42605, 42625, 42625, 42627, 42627, 42629, 42629, 42631, 42631, 42633, 42633, 42635, 42635, 42637, 42637, 42639, 42639, 42641, 42641, 42643, 42643, 42645, 42645, 42647, 42647, 42787, 42787, 42789, 42789, 42791, 42791, 42793, 42793, 42795, 42795, 42797, 42797, 42799, 42801, 42803, 42803, 42805, 42805, 42807, 42807, 42809, 42809, 42811, 42811, 42813, 42813, 42815, 42815, 42817, 42817, 42819, 42819, 42821, 42821, 42823, 42823, 42825, 42825, 42827, 42827, 42829, 42829, 42831, 42831, 42833, 42833, 42835, 42835, 42837, 42837, 42839, 42839, 42841, 42841, 42843, 42843, 42845, 42845, 42847, 42847, 42849, 42849, 42851, 42851, 42853, 42853, 42855, 42855, 42857, 42857, 42859, 42859, 42861, 42861, 42863, 42863, 42865, 42872, 42874, 42874, 42876, 42876, 42879, 42879, 42881, 42881, 42883, 42883, 42885, 42885, 42887, 42887, 42892, 42892, 42894, 42894, 42897, 42897, 42899, 42899, 42913, 42913, 42915, 42915, 42917, 42917, 42919, 42919, 42921, 42921, 43002, 43002, 64256, 64262, 64275, 64279, 65345, 65370, 51, 0, 688, 705, 710, 721, 736, 740, 748, 748, 750, 750, 884, 884, 890, 890, 1369, 1369, 1600, 1600, 1765, 1766, 2036, 2037, 2042, 2042, 2074, 2074, 2084, 2084, 2088, 2088, 2417, 2417, 3654, 3654, 3782, 3782, 4348, 4348, 6103, 6103, 6211, 6211, 6823, 6823, 7288, 7293, 7468, 7530, 7544, 7544, 7579, 7615, 8305, 8305, 8319, 8319, 8336, 8348, 11388, 11389, 11631, 11631, 11823, 11823, 12293, 12293, 12337, 12341, 12347, 12347, 12445, 12446, 12540, 12542, 40981, 40981, 42232, 42237, 42508, 42508, 42623, 42623, 42775, 42783, 42864, 42864, 42888, 42888, 43000, 43001, 43471, 43471, 43632, 43632, 43741, 43741, 43763, 43764, 65392, 65392, 65438, 65439, 289, 0, 170, 170, 186, 186, 443, 443, 448, 451, 660, 660, 1488, 1514, 1520, 1522, 1568, 1599, 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2048, 2069, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2418, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3653, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4304, 4346, 4349, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6108, 6108, 6176, 6210, 6212, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7401, 7404, 7406, 7409, 7413, 7414, 8501, 8504, 11568, 11623, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12294, 12294, 12348, 12348, 12353, 12438, 12447, 12447, 12449, 12538, 12543, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 13312, 19893, 19893, 19968, 19968, 40908, 40908, 40960, 40980, 40982, 42124, 42192, 42231, 42240, 42507, 42512, 42527, 42538, 42539, 42606, 42606, 42656, 42725, 43003, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43633, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43740, 43744, 43754, 43762, 43762, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 44032, 55203, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65382, 65391, 65393, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 10, 0, 453, 453, 456, 456, 459, 459, 498, 498, 8072, 8079, 8088, 8095, 8104, 8111, 8124, 8124, 8140, 8140, 8188, 8188, 576, 0, 65, 90, 192, 214, 216, 222, 256, 256, 258, 258, 260, 260, 262, 262, 264, 264, 266, 266, 268, 268, 270, 270, 272, 272, 274, 274, 276, 276, 278, 278, 280, 280, 282, 282, 284, 284, 286, 286, 288, 288, 290, 290, 292, 292, 294, 294, 296, 296, 298, 298, 300, 300, 302, 302, 304, 304, 306, 306, 308, 308, 310, 310, 313, 313, 315, 315, 317, 317, 319, 319, 321, 321, 323, 323, 325, 325, 327, 327, 330, 330, 332, 332, 334, 334, 336, 336, 338, 338, 340, 340, 342, 342, 344, 344, 346, 346, 348, 348, 350, 350, 352, 352, 354, 354, 356, 356, 358, 358, 360, 360, 362, 362, 364, 364, 366, 366, 368, 368, 370, 370, 372, 372, 374, 374, 376, 377, 379, 379, 381, 381, 385, 386, 388, 388, 390, 391, 393, 395, 398, 401, 403, 404, 406, 408, 412, 413, 415, 416, 418, 418, 420, 420, 422, 423, 425, 425, 428, 428, 430, 431, 433, 435, 437, 437, 439, 440, 444, 444, 452, 452, 455, 455, 458, 458, 461, 461, 463, 463, 465, 465, 467, 467, 469, 469, 471, 471, 473, 473, 475, 475, 478, 478, 480, 480, 482, 482, 484, 484, 486, 486, 488, 488, 490, 490, 492, 492, 494, 494, 497, 497, 500, 500, 502, 504, 506, 506, 508, 508, 510, 510, 512, 512, 514, 514, 516, 516, 518, 518, 520, 520, 522, 522, 524, 524, 526, 526, 528, 528, 530, 530, 532, 532, 534, 534, 536, 536, 538, 538, 540, 540, 542, 542, 544, 544, 546, 546, 548, 548, 550, 550, 552, 552, 554, 554, 556, 556, 558, 558, 560, 560, 562, 562, 570, 571, 573, 574, 577, 577, 579, 582, 584, 584, 586, 586, 588, 588, 590, 590, 880, 880, 882, 882, 886, 886, 902, 902, 904, 906, 908, 908, 910, 911, 913, 929, 931, 939, 975, 975, 978, 980, 984, 984, 986, 986, 988, 988, 990, 990, 992, 992, 994, 994, 996, 996, 998, 998, 1000, 1000, 1002, 1002, 1004, 1004, 1006, 1006, 1012, 1012, 1015, 1015, 1017, 1018, 1021, 1071, 1120, 1120, 1122, 1122, 1124, 1124, 1126, 1126, 1128, 1128, 1130, 1130, 1132, 1132, 1134, 1134, 1136, 1136, 1138, 1138, 1140, 1140, 1142, 1142, 1144, 1144, 1146, 1146, 1148, 1148, 1150, 1150, 1152, 1152, 1162, 1162, 1164, 1164, 1166, 1166, 1168, 1168, 1170, 1170, 1172, 1172, 1174, 1174, 1176, 1176, 1178, 1178, 1180, 1180, 1182, 1182, 1184, 1184, 1186, 1186, 1188, 1188, 1190, 1190, 1192, 1192, 1194, 1194, 1196, 1196, 1198, 1198, 1200, 1200, 1202, 1202, 1204, 1204, 1206, 1206, 1208, 1208, 1210, 1210, 1212, 1212, 1214, 1214, 1216, 1217, 1219, 1219, 1221, 1221, 1223, 1223, 1225, 1225, 1227, 1227, 1229, 1229, 1232, 1232, 1234, 1234, 1236, 1236, 1238, 1238, 1240, 1240, 1242, 1242, 1244, 1244, 1246, 1246, 1248, 1248, 1250, 1250, 1252, 1252, 1254, 1254, 1256, 1256, 1258, 1258, 1260, 1260, 1262, 1262, 1264, 1264, 1266, 1266, 1268, 1268, 1270, 1270, 1272, 1272, 1274, 1274, 1276, 1276, 1278, 1278, 1280, 1280, 1282, 1282, 1284, 1284, 1286, 1286, 1288, 1288, 1290, 1290, 1292, 1292, 1294, 1294, 1296, 1296, 1298, 1298, 1300, 1300, 1302, 1302, 1304, 1304, 1306, 1306, 1308, 1308, 1310, 1310, 1312, 1312, 1314, 1314, 1316, 1316, 1318, 1318, 1329, 1366, 4256, 4293, 4295, 4295, 4301, 4301, 7680, 7680, 7682, 7682, 7684, 7684, 7686, 7686, 7688, 7688, 7690, 7690, 7692, 7692, 7694, 7694, 7696, 7696, 7698, 7698, 7700, 7700, 7702, 7702, 7704, 7704, 7706, 7706, 7708, 7708, 7710, 7710, 7712, 7712, 7714, 7714, 7716, 7716, 7718, 7718, 7720, 7720, 7722, 7722, 7724, 7724, 7726, 7726, 7728, 7728, 7730, 7730, 7732, 7732, 7734, 7734, 7736, 7736, 7738, 7738, 7740, 7740, 7742, 7742, 7744, 7744, 7746, 7746, 7748, 7748, 7750, 7750, 7752, 7752, 7754, 7754, 7756, 7756, 7758, 7758, 7760, 7760, 7762, 7762, 7764, 7764, 7766, 7766, 7768, 7768, 7770, 7770, 7772, 7772, 7774, 7774, 7776, 7776, 7778, 7778, 7780, 7780, 7782, 7782, 7784, 7784, 7786, 7786, 7788, 7788, 7790, 7790, 7792, 7792, 7794, 7794, 7796, 7796, 7798, 7798, 7800, 7800, 7802, 7802, 7804, 7804, 7806, 7806, 7808, 7808, 7810, 7810, 7812, 7812, 7814, 7814, 7816, 7816, 7818, 7818, 7820, 7820, 7822, 7822, 7824, 7824, 7826, 7826, 7828, 7828, 7838, 7838, 7840, 7840, 7842, 7842, 7844, 7844, 7846, 7846, 7848, 7848, 7850, 7850, 7852, 7852, 7854, 7854, 7856, 7856, 7858, 7858, 7860, 7860, 7862, 7862, 7864, 7864, 7866, 7866, 7868, 7868, 7870, 7870, 7872, 7872, 7874, 7874, 7876, 7876, 7878, 7878, 7880, 7880, 7882, 7882, 7884, 7884, 7886, 7886, 7888, 7888, 7890, 7890, 7892, 7892, 7894, 7894, 7896, 7896, 7898, 7898, 7900, 7900, 7902, 7902, 7904, 7904, 7906, 7906, 7908, 7908, 7910, 7910, 7912, 7912, 7914, 7914, 7916, 7916, 7918, 7918, 7920, 7920, 7922, 7922, 7924, 7924, 7926, 7926, 7928, 7928, 7930, 7930, 7932, 7932, 7934, 7934, 7944, 7951, 7960, 7965, 7976, 7983, 7992, 7999, 8008, 8013, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8031, 8040, 8047, 8120, 8123, 8136, 8139, 8152, 8155, 8168, 8172, 8184, 8187, 8450, 8450, 8455, 8455, 8459, 8461, 8464, 8466, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8496, 8499, 8510, 8511, 8517, 8517, 8579, 8579, 11264, 11310, 11360, 11360, 11362, 11364, 11367, 11367, 11369, 11369, 11371, 11371, 11373, 11376, 11378, 11378, 11381, 11381, 11390, 11392, 11394, 11394, 11396, 11396, 11398, 11398, 11400, 11400, 11402, 11402, 11404, 11404, 11406, 11406, 11408, 11408, 11410, 11410, 11412, 11412, 11414, 11414, 11416, 11416, 11418, 11418, 11420, 11420, 11422, 11422, 11424, 11424, 11426, 11426, 11428, 11428, 11430, 11430, 11432, 11432, 11434, 11434, 11436, 11436, 11438, 11438, 11440, 11440, 11442, 11442, 11444, 11444, 11446, 11446, 11448, 11448, 11450, 11450, 11452, 11452, 11454, 11454, 11456, 11456, 11458, 11458, 11460, 11460, 11462, 11462, 11464, 11464, 11466, 11466, 11468, 11468, 11470, 11470, 11472, 11472, 11474, 11474, 11476, 11476, 11478, 11478, 11480, 11480, 11482, 11482, 11484, 11484, 11486, 11486, 11488, 11488, 11490, 11490, 11499, 11499, 11501, 11501, 11506, 11506, 42560, 42560, 42562, 42562, 42564, 42564, 42566, 42566, 42568, 42568, 42570, 42570, 42572, 42572, 42574, 42574, 42576, 42576, 42578, 42578, 42580, 42580, 42582, 42582, 42584, 42584, 42586, 42586, 42588, 42588, 42590, 42590, 42592, 42592, 42594, 42594, 42596, 42596, 42598, 42598, 42600, 42600, 42602, 42602, 42604, 42604, 42624, 42624, 42626, 42626, 42628, 42628, 42630, 42630, 42632, 42632, 42634, 42634, 42636, 42636, 42638, 42638, 42640, 42640, 42642, 42642, 42644, 42644, 42646, 42646, 42786, 42786, 42788, 42788, 42790, 42790, 42792, 42792, 42794, 42794, 42796, 42796, 42798, 42798, 42802, 42802, 42804, 42804, 42806, 42806, 42808, 42808, 42810, 42810, 42812, 42812, 42814, 42814, 42816, 42816, 42818, 42818, 42820, 42820, 42822, 42822, 42824, 42824, 42826, 42826, 42828, 42828, 42830, 42830, 42832, 42832, 42834, 42834, 42836, 42836, 42838, 42838, 42840, 42840, 42842, 42842, 42844, 42844, 42846, 42846, 42848, 42848, 42850, 42850, 42852, 42852, 42854, 42854, 42856, 42856, 42858, 42858, 42860, 42860, 42862, 42862, 42873, 42873, 42875, 42875, 42877, 42878, 42880, 42880, 42882, 42882, 42884, 42884, 42886, 42886, 42891, 42891, 42893, 42893, 42896, 42896, 42898, 42898, 42912, 42912, 42914, 42914, 42916, 42916, 42918, 42918, 42920, 42920, 42922, 42922, 65313, 65338, 35, 0, 48, 57, 1632, 1641, 1776, 1785, 1984, 1993, 2406, 2415, 2534, 2543, 2662, 2671, 2790, 2799, 2918, 2927, 3046, 3055, 3174, 3183, 3302, 3311, 3430, 3439, 3664, 3673, 3792, 3801, 3872, 3881, 4160, 4169, 4240, 4249, 6112, 6121, 6160, 6169, 6470, 6479, 6608, 6617, 6784, 6793, 6800, 6809, 6992, 7001, 7088, 7097, 7232, 7241, 7248, 7257, 42528, 42537, 43216, 43225, 43264, 43273, 43472, 43481, 43600, 43609, 44016, 44025, 65296, 65305, 7, 0, 5870, 5872, 8544, 8578, 8581, 8584, 12295, 12295, 12321, 12329, 12344, 12346, 42726, 42735, 3, 0, 34, 34, 36, 36, 92, 92, 2, 0, 34, 34, 36, 36, 2326, 0, 4, 1, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 8, 1, 0, 0, 0, 0, 10, 1, 0, 0, 0, 0, 12, 1, 0, 0, 0, 0, 16, 1, 0, 0, 0, 0, 18, 1, 0, 0, 0, 0, 20, 1, 0, 0, 0, 0, 22, 1, 0, 0, 0, 0, 24, 1, 0, 0, 0, 0, 26, 1, 0, 0, 0, 0, 28, 1, 0, 0, 0, 0, 30, 1, 0, 0, 0, 0, 32, 1, 0, 0, 0, 0, 34, 1, 0, 0, 0, 0, 36, 1, 0, 0, 0, 0, 38, 1, 0, 0, 0, 0, 40, 1, 0, 0, 0, 0, 42, 1, 0, 0, 0, 0, 44, 1, 0, 0, 0, 0, 46, 1, 0, 0, 0, 0, 48, 1, 0, 0, 0, 0, 50, 1, 0, 0, 0, 0, 52, 1, 0, 0, 0, 0, 54, 1, 0, 0, 0, 0, 56, 1, 0, 0, 0, 0, 58, 1, 0, 0, 0, 0, 60, 1, 0, 0, 0, 0, 62, 1, 0, 0, 0, 0, 64, 1, 0, 0, 0, 0, 66, 1, 0, 0, 0, 0, 68, 1, 0, 0, 0, 0, 70, 1, 0, 0, 0, 0, 72, 1, 0, 0, 0, 0, 74, 1, 0, 0, 0, 0, 76, 1, 0, 0, 0, 0, 78, 1, 0, 0, 0, 0, 80, 1, 0, 0, 0, 0, 82, 1, 0, 0, 0, 0, 84, 1, 0, 0, 0, 0, 86, 1, 0, 0, 0, 0, 88, 1, 0, 0, 0, 0, 90, 1, 0, 0, 0, 0, 92, 1, 0, 0, 0, 0, 94, 1, 0, 0, 0, 0, 96, 1, 0, 0, 0, 0, 98, 1, 0, 0, 0, 0, 100, 1, 0, 0, 0, 0, 102, 1, 0, 0, 0, 0, 104, 1, 0, 0, 0, 0, 106, 1, 0, 0, 0, 0, 108, 1, 0, 0, 0, 0, 110, 1, 0, 0, 0, 0, 112, 1, 0, 0, 0, 0, 114, 1, 0, 0, 0, 0, 116, 1, 0, 0, 0, 0, 118, 1, 0, 0, 0, 0, 120, 1, 0, 0, 0, 0, 122, 1, 0, 0, 0, 0, 124, 1, 0, 0, 0, 0, 126, 1, 0, 0, 0, 0, 128, 1, 0, 0, 0, 0, 130, 1, 0, 0, 0, 0, 132, 1, 0, 0, 0, 0, 134, 1, 0, 0, 0, 0, 136, 1, 0, 0, 0, 0, 138, 1, 0, 0, 0, 0, 140, 1, 0, 0, 0, 0, 142, 1, 0, 0, 0, 0, 144, 1, 0, 0, 0, 0, 146, 1, 0, 0, 0, 0, 148, 1, 0, 0, 0, 0, 150, 1, 0, 0, 0, 0, 152, 1, 0, 0, 0, 0, 154, 1, 0, 0, 0, 0, 156, 1, 0, 0, 0, 0, 158, 1, 0, 0, 0, 0, 160, 1, 0, 0, 0, 0, 162, 1, 0, 0, 0, 0, 164, 1, 0, 0, 0, 0, 166, 1, 0, 0, 0, 0, 168, 1, 0, 0, 0, 0, 170, 1, 0, 0, 0, 0, 172, 1, 0, 0, 0, 0, 174, 1, 0, 0, 0, 0, 176, 1, 0, 0, 0, 0, 178, 1, 0, 0, 0, 0, 180, 1, 0, 0, 0, 0, 182, 1, 0, 0, 0, 0, 184, 1, 0, 0, 0, 0, 186, 1, 0, 0, 0, 0, 188, 1, 0, 0, 0, 0, 190, 1, 0, 0, 0, 0, 192, 1, 0, 0, 0, 0, 194, 1, 0, 0, 0, 0, 196, 1, 0, 0, 0, 0, 198, 1, 0, 0, 0, 0, 200, 1, 0, 0, 0, 0, 202, 1, 0, 0, 0, 0, 204, 1, 0, 0, 0, 0, 206, 1, 0, 0, 0, 0, 208, 1, 0, 0, 0, 0, 210, 1, 0, 0, 0, 0, 212, 1, 0, 0, 0, 0, 214, 1, 0, 0, 0, 0, 216, 1, 0, 0, 0, 0, 218, 1, 0, 0, 0, 0, 220, 1, 0, 0, 0, 0, 222, 1, 0, 0, 0, 0, 224, 1, 0, 0, 0, 0, 226, 1, 0, 0, 0, 0, 228, 1, 0, 0, 0, 0, 230, 1, 0, 0, 0, 0, 232, 1, 0, 0, 0, 0, 234, 1, 0, 0, 0, 0, 236, 1, 0, 0, 0, 0, 238, 1, 0, 0, 0, 0, 240, 1, 0, 0, 0, 0, 242, 1, 0, 0, 0, 0, 244, 1, 0, 0, 0, 0, 246, 1, 0, 0, 0, 0, 248, 1, 0, 0, 0, 0, 250, 1, 0, 0, 0, 0, 252, 1, 0, 0, 0, 0, 254, 1, 0, 0, 0, 0, 256, 1, 0, 0, 0, 0, 258, 1, 0, 0, 0, 0, 260, 1, 0, 0, 0, 0, 262, 1, 0, 0, 0, 0, 264, 1, 0, 0, 0, 0, 266, 1, 0, 0, 0, 0, 268, 1, 0, 0, 0, 0, 270, 1, 0, 0, 0, 0, 272, 1, 0, 0, 0, 0, 274, 1, 0, 0, 0, 0, 286, 1, 0, 0, 0, 0, 288, 1, 0, 0, 0, 0, 290, 1, 0, 0, 0, 0, 292, 1, 0, 0, 0, 0, 298, 1, 0, 0, 0, 0, 304, 1, 0, 0, 0, 0, 306, 1, 0, 0, 0, 0, 308, 1, 0, 0, 0, 0, 310, 1, 0, 0, 0, 0, 312, 1, 0, 0, 0, 0, 314, 1, 0, 0, 0, 0, 318, 1, 0, 0, 0, 0, 320, 1, 0, 0, 0, 0, 322, 1, 0, 0, 0, 0, 332, 1, 0, 0, 0, 0, 334, 1, 0, 0, 0, 0, 336, 1, 0, 0, 0, 0, 338, 1, 0, 0, 0, 0, 340, 1, 0, 0, 0, 0, 342, 1, 0, 0, 0, 0, 344, 1, 0, 0, 0, 0, 346, 1, 0, 0, 0, 0, 348, 1, 0, 0, 0, 0, 630, 1, 0, 0, 0, 1, 350, 1, 0, 0, 0, 1, 352, 1, 0, 0, 0, 1, 354, 1, 0, 0, 0, 1, 356, 1, 0, 0, 0, 1, 358, 1, 0, 0, 0, 2, 360, 1, 0, 0, 0, 2, 362, 1, 0, 0, 0, 2, 364, 1, 0, 0, 0, 2, 366, 1, 0, 0, 0, 2, 368, 1, 0, 0, 0, 3, 370, 1, 0, 0, 0, 3, 372, 1, 0, 0, 0, 3, 374, 1, 0, 0, 0, 3, 376, 1, 0, 0, 0, 3, 378, 1, 0, 0, 0, 3, 380, 1, 0, 0, 0, 3, 382, 1, 0, 0, 0, 3, 384, 1, 0, 0, 0, 3, 386, 1, 0, 0, 0, 3, 388, 1, 0, 0, 0, 3, 390, 1, 0, 0, 0, 3, 392, 1, 0, 0, 0, 3, 394, 1, 0, 0, 0, 3, 396, 1, 0, 0, 0, 3, 398, 1, 0, 0, 0, 3, 400, 1, 0, 0, 0, 3, 402, 1, 0, 0, 0, 3, 404, 1, 0, 0, 0, 3, 406, 1, 0, 0, 0, 3, 408, 1, 0, 0, 0, 3, 410, 1, 0, 0, 0, 3, 412, 1, 0, 0, 0, 3, 414, 1, 0, 0, 0, 3, 416, 1, 0, 0, 0, 3, 418, 1, 0, 0, 0, 3, 420, 1, 0, 0, 0, 3, 422, 1, 0, 0, 0, 3, 424, 1, 0, 0, 0, 3, 426, 1, 0, 0, 0, 3, 428, 1, 0, 0, 0, 3, 430, 1, 0, 0, 0, 3, 432, 1, 0, 0, 0, 3, 434, 1, 0, 0, 0, 3, 436, 1, 0, 0, 0, 3, 438, 1, 0, 0, 0, 3, 440, 1, 0, 0, 0, 3, 442, 1, 0, 0, 0, 3, 444, 1, 0, 0, 0, 3, 446, 1, 0, 0, 0, 3, 448, 1, 0, 0, 0, 3, 450, 1, 0, 0, 0, 3, 452, 1, 0, 0, 0, 3, 454, 1, 0, 0, 0, 3, 456, 1, 0, 0, 0, 3, 458, 1, 0, 0, 0, 3, 460, 1, 0, 0, 0, 3, 462, 1, 0, 0, 0, 3, 464, 1, 0, 0, 0, 3, 466, 1, 0, 0, 0, 3, 468, 1, 0, 0, 0, 3, 470, 1, 0, 0, 0, 3, 472, 1, 0, 0, 0, 3, 474, 1, 0, 0, 0, 3, 476, 1, 0, 0, 0, 3, 478, 1, 0, 0, 0, 3, 480, 1, 0, 0, 0, 3, 482, 1, 0, 0, 0, 3, 484, 1, 0, 0, 0, 3, 486, 1, 0, 0, 0, 3, 488, 1, 0, 0, 0, 3, 490, 1, 0, 0, 0, 3, 492, 1, 0, 0, 0, 3, 494, 1, 0, 0, 0, 3, 496, 1, 0, 0, 0, 3, 498, 1, 0, 0, 0, 3, 500, 1, 0, 0, 0, 3, 502, 1, 0, 0, 0, 3, 504, 1, 0, 0, 0, 3, 506, 1, 0, 0, 0, 3, 508, 1, 0, 0, 0, 3, 510, 1, 0, 0, 0, 3, 512, 1, 0, 0, 0, 3, 514, 1, 0, 0, 0, 3, 516, 1, 0, 0, 0, 3, 518, 1, 0, 0, 0, 3, 520, 1, 0, 0, 0, 3, 522, 1, 0, 0, 0, 3, 524, 1, 0, 0, 0, 3, 526, 1, 0, 0, 0, 3, 528, 1, 0, 0, 0, 3, 530, 1, 0, 0, 0, 3, 532, 1, 0, 0, 0, 3, 534, 1, 0, 0, 0, 3, 536, 1, 0, 0, 0, 3, 538, 1, 0, 0, 0, 3, 540, 1, 0, 0, 0, 3, 542, 1, 0, 0, 0, 3, 544, 1, 0, 0, 0, 3, 546, 1, 0, 0, 0, 3, 548, 1, 0, 0, 0, 3, 550, 1, 0, 0, 0, 3, 552, 1, 0, 0, 0, 3, 554, 1, 0, 0, 0, 3, 556, 1, 0, 0, 0, 3, 558, 1, 0, 0, 0, 3, 560, 1, 0, 0, 0, 3, 562, 1, 0, 0, 0, 3, 564, 1, 0, 0, 0, 3, 566, 1, 0, 0, 0, 3, 568, 1, 0, 0, 0, 3, 570, 1, 0, 0, 0, 3, 572, 1, 0, 0, 0, 3, 574, 1, 0, 0, 0, 3, 576, 1, 0, 0, 0, 3, 578, 1, 0, 0, 0, 3, 580, 1, 0, 0, 0, 3, 582, 1, 0, 0, 0, 3, 584, 1, 0, 0, 0, 3, 586, 1, 0, 0, 0, 3, 588, 1, 0, 0, 0, 3, 590, 1, 0, 0, 0, 3, 592, 1, 0, 0, 0, 3, 594, 1, 0, 0, 0, 3, 596, 1, 0, 0, 0, 3, 598, 1, 0, 0, 0, 3, 600, 1, 0, 0, 0, 3, 602, 1, 0, 0, 0, 3, 604, 1, 0, 0, 0, 3, 606, 1, 0, 0, 0, 3, 608, 1, 0, 0, 0, 3, 610, 1, 0, 0, 0, 3, 612, 1, 0, 0, 0, 3, 614, 1, 0, 0, 0, 3, 616, 1, 0, 0, 0, 3, 618, 1, 0, 0, 0, 3, 620, 1, 0, 0, 0, 3, 622, 1, 0, 0, 0, 3, 624, 1, 0, 0, 0, 3, 626, 1, 0, 0, 0, 3, 628, 1, 0, 0, 0, 4, 632, 1, 0, 0, 0, 6, 641, 1, 0, 0, 0, 8, 656, 1, 0, 0, 0, 10, 667, 1, 0, 0, 0, 12, 676, 1, 0, 0, 0, 14, 681, 1, 0, 0, 0, 16, 683, 1, 0, 0, 0, 18, 687, 1, 0, 0, 0, 20, 689, 1, 0, 0, 0, 22, 691, 1, 0, 0, 0, 24, 695, 1, 0, 0, 0, 26, 697, 1, 0, 0, 0, 28, 701, 1, 0, 0, 0, 30, 703, 1, 0, 0, 0, 32, 707, 1, 0, 0, 0, 34, 711, 1, 0, 0, 0, 36, 713, 1, 0, 0, 0, 38, 715, 1, 0, 0, 0, 40, 717, 1, 0, 0, 0, 42, 719, 1, 0, 0, 0, 44, 721, 1, 0, 0, 0, 46, 724, 1, 0, 0, 0, 48, 727, 1, 0, 0, 0, 50, 730, 1, 0, 0, 0, 52, 733, 1, 0, 0, 0, 54, 736, 1, 0, 0, 0, 56, 738, 1, 0, 0, 0, 58, 740, 1, 0, 0, 0, 60, 742, 1, 0, 0, 0, 62, 744, 1, 0, 0, 0, 64, 747, 1, 0, 0, 0, 66, 750, 1, 0, 0, 0, 68, 753, 1, 0, 0, 0, 70, 756, 1, 0, 0, 0, 72, 759, 1, 0, 0, 0, 74, 762, 1, 0, 0, 0, 76, 765, 1, 0, 0, 0, 78, 768, 1, 0, 0, 0, 80, 771, 1, 0, 0, 0, 82, 774, 1, 0, 0, 0, 84, 776, 1, 0, 0, 0, 86, 778, 1, 0, 0, 0, 88, 785, 1, 0, 0, 0, 90, 791, 1, 0, 0, 0, 92, 798, 1, 0, 0, 0, 94, 801, 1, 0, 0, 0, 96, 803, 1, 0, 0, 0, 98, 805, 1, 0, 0, 0, 100, 807, 1, 0, 0, 0, 102, 810, 1, 0, 0, 0, 104, 813, 1, 0, 0, 0, 106, 816, 1, 0, 0, 0, 108, 820, 1, 0, 0, 0, 110, 824, 1, 0, 0, 0, 112, 827, 1, 0, 0, 0, 114, 831, 1, 0, 0, 0, 116, 833, 1, 0, 0, 0, 118, 835, 1, 0, 0, 0, 120, 845, 1, 0, 0, 0, 122, 857, 1, 0, 0, 0, 124, 866, 1, 0, 0, 0, 126, 874, 1, 0, 0, 0, 128, 883, 1, 0, 0, 0, 130, 888, 1, 0, 0, 0, 132, 894, 1, 0, 0, 0, 134, 903, 1, 0, 0, 0, 136, 907, 1, 0, 0, 0, 138, 911, 1, 0, 0, 0, 140, 920, 1, 0, 0, 0, 142, 926, 1, 0, 0, 0, 144, 935, 1, 0, 0, 0, 146, 944, 1, 0, 0, 0, 148, 952, 1, 0, 0, 0, 150, 959, 1, 0, 0, 0, 152, 965, 1, 0, 0, 0, 154, 975, 1, 0, 0, 0, 156, 979, 1, 0, 0, 0, 158, 986, 1, 0, 0, 0, 160, 990, 1, 0, 0, 0, 162, 994, 1, 0, 0, 0, 164, 1004, 1, 0, 0, 0, 166, 1016, 1, 0, 0, 0, 168, 1019, 1, 0, 0, 0, 170, 1029, 1, 0, 0, 0, 172, 1034, 1, 0, 0, 0, 174, 1039, 1, 0, 0, 0, 176, 1045, 1, 0, 0, 0, 178, 1052, 1, 0, 0, 0, 180, 1058, 1, 0, 0, 0, 182, 1061, 1, 0, 0, 0, 184, 1066, 1, 0, 0, 0, 186, 1071, 1, 0, 0, 0, 188, 1075, 1, 0, 0, 0, 190, 1081, 1, 0, 0, 0, 192, 1089, 1, 0, 0, 0, 194, 1093, 1, 0, 0, 0, 196, 1096, 1, 0, 0, 0, 198, 1102, 1, 0, 0, 0, 200, 1108, 1, 0, 0, 0, 202, 1115, 1, 0, 0, 0, 204, 1124, 1, 0, 0, 0, 206, 1130, 1, 0, 0, 0, 208, 1133, 1, 0, 0, 0, 210, 1136, 1, 0, 0, 0, 212, 1139, 1, 0, 0, 0, 214, 1147, 1, 0, 0, 0, 216, 1155, 1, 0, 0, 0, 218, 1159, 1, 0, 0, 0, 220, 1167, 1, 0, 0, 0, 222, 1174, 1, 0, 0, 0, 224, 1182, 1, 0, 0, 0, 226, 1192, 1, 0, 0, 0, 228, 1201, 1, 0, 0, 0, 230, 1206, 1, 0, 0, 0, 232, 1213, 1, 0, 0, 0, 234, 1224, 1, 0, 0, 0, 236, 1229, 1, 0, 0, 0, 238, 1235, 1, 0, 0, 0, 240, 1241, 1, 0, 0, 0, 242, 1249, 1, 0, 0, 0, 244, 1258, 1, 0, 0, 0, 246, 1265, 1, 0, 0, 0, 248, 1271, 1, 0, 0, 0, 250, 1280, 1, 0, 0, 0, 252, 1288, 1, 0, 0, 0, 254, 1297, 1, 0, 0, 0, 256, 1306, 1, 0, 0, 0, 258, 1312, 1, 0, 0, 0, 260, 1317, 1, 0, 0, 0, 262, 1323, 1, 0, 0, 0, 264, 1332, 1, 0, 0, 0, 266, 1339, 1, 0, 0, 0, 268, 1348, 1, 0, 0, 0, 270, 1360, 1, 0, 0, 0, 272, 1368, 1, 0, 0, 0, 274, 1375, 1, 0, 0, 0, 276, 1382, 1, 0, 0, 0, 278, 1384, 1, 0, 0, 0, 280, 1388, 1, 0, 0, 0, 282, 1400, 1, 0, 0, 0, 284, 1402, 1, 0, 0, 0, 286, 1410, 1, 0, 0, 0, 288, 1418, 1, 0, 0, 0, 290, 1431, 1, 0, 0, 0, 292, 1443, 1, 0, 0, 0, 294, 1445, 1, 0, 0, 0, 296, 1449, 1, 0, 0, 0, 298, 1465, 1, 0, 0, 0, 300, 1467, 1, 0, 0, 0, 302, 1471, 1, 0, 0, 0, 304, 1487, 1, 0, 0, 0, 306, 1492, 1, 0, 0, 0, 308, 1501, 1, 0, 0, 0, 310, 1514, 1, 0, 0, 0, 312, 1516, 1, 0, 0, 0, 314, 1521, 1, 0, 0, 0, 316, 1528, 1, 0, 0, 0, 318, 1549, 1, 0, 0, 0, 320, 1599, 1, 0, 0, 0, 322, 1601, 1, 0, 0, 0, 324, 1604, 1, 0, 0, 0, 326, 1611, 1, 0, 0, 0, 328, 1616, 1, 0, 0, 0, 330, 1623, 1, 0, 0, 0, 332, 1625, 1, 0, 0, 0, 334, 1629, 1, 0, 0, 0, 336, 1635, 1, 0, 0, 0, 338, 1637, 1, 0, 0, 0, 340, 1639, 1, 0, 0, 0, 342, 1641, 1, 0, 0, 0, 344, 1643, 1, 0, 0, 0, 346, 1645, 1, 0, 0, 0, 348, 1647, 1, 0, 0, 0, 350, 1649, 1, 0, 0, 0, 352, 1653, 1, 0, 0, 0, 354, 1661, 1, 0, 0, 0, 356, 1665, 1, 0, 0, 0, 358, 1667, 1, 0, 0, 0, 360, 1673, 1, 0, 0, 0, 362, 1682, 1, 0, 0, 0, 364, 1686, 1, 0, 0, 0, 366, 1694, 1, 0, 0, 0, 368, 1696, 1, 0, 0, 0, 370, 1701, 1, 0, 0, 0, 372, 1706, 1, 0, 0, 0, 374, 1711, 1, 0, 0, 0, 376, 1716, 1, 0, 0, 0, 378, 1721, 1, 0, 0, 0, 380, 1726, 1, 0, 0, 0, 382, 1731, 1, 0, 0, 0, 384, 1735, 1, 0, 0, 0, 386, 1739, 1, 0, 0, 0, 388, 1743, 1, 0, 0, 0, 390, 1747, 1, 0, 0, 0, 392, 1751, 1, 0, 0, 0, 394, 1755, 1, 0, 0, 0, 396, 1759, 1, 0, 0, 0, 398, 1763, 1, 0, 0, 0, 400, 1767, 1, 0, 0, 0, 402, 1771, 1, 0, 0, 0, 404, 1775, 1, 0, 0, 0, 406, 1782, 1, 0, 0, 0, 408, 1786, 1, 0, 0, 0, 410, 1790, 1, 0, 0, 0, 412, 1794, 1, 0, 0, 0, 414, 1798, 1, 0, 0, 0, 416, 1802, 1, 0, 0, 0, 418, 1806, 1, 0, 0, 0, 420, 1810, 1, 0, 0, 0, 422, 1814, 1, 0, 0, 0, 424, 1818, 1, 0, 0, 0, 426, 1822, 1, 0, 0, 0, 428, 1826, 1, 0, 0, 0, 430, 1830, 1, 0, 0, 0, 432, 1834, 1, 0, 0, 0, 434, 1838, 1, 0, 0, 0, 436, 1842, 1, 0, 0, 0, 438, 1846, 1, 0, 0, 0, 440, 1850, 1, 0, 0, 0, 442, 1854, 1, 0, 0, 0, 444, 1858, 1, 0, 0, 0, 446, 1862, 1, 0, 0, 0, 448, 1869, 1, 0, 0, 0, 450, 1873, 1, 0, 0, 0, 452, 1877, 1, 0, 0, 0, 454, 1881, 1, 0, 0, 0, 456, 1885, 1, 0, 0, 0, 458, 1889, 1, 0, 0, 0, 460, 1893, 1, 0, 0, 0, 462, 1897, 1, 0, 0, 0, 464, 1901, 1, 0, 0, 0, 466, 1905, 1, 0, 0, 0, 468, 1909, 1, 0, 0, 0, 470, 1913, 1, 0, 0, 0, 472, 1917, 1, 0, 0, 0, 474, 1921, 1, 0, 0, 0, 476, 1925, 1, 0, 0, 0, 478, 1929, 1, 0, 0, 0, 480, 1933, 1, 0, 0, 0, 482, 1938, 1, 0, 0, 0, 484, 1943, 1, 0, 0, 0, 486, 1947, 1, 0, 0, 0, 488, 1951, 1, 0, 0, 0, 490, 1955, 1, 0, 0, 0, 492, 1959, 1, 0, 0, 0, 494, 1963, 1, 0, 0, 0, 496, 1967, 1, 0, 0, 0, 498, 1971, 1, 0, 0, 0, 500, 1975, 1, 0, 0, 0, 502, 1979, 1, 0, 0, 0, 504, 1983, 1, 0, 0, 0, 506, 1987, 1, 0, 0, 0, 508, 1991, 1, 0, 0, 0, 510, 1995, 1, 0, 0, 0, 512, 1999, 1, 0, 0, 0, 514, 2003, 1, 0, 0, 0, 516, 2007, 1, 0, 0, 0, 518, 2011, 1, 0, 0, 0, 520, 2015, 1, 0, 0, 0, 522, 2019, 1, 0, 0, 0, 524, 2023, 1, 0, 0, 0, 526, 2027, 1, 0, 0, 0, 528, 2031, 1, 0, 0, 0, 530, 2035, 1, 0, 0, 0, 532, 2039, 1, 0, 0, 0, 534, 2043, 1, 0, 0, 0, 536, 2047, 1, 0, 0, 0, 538, 2051, 1, 0, 0, 0, 540, 2055, 1, 0, 0, 0, 542, 2059, 1, 0, 0, 0, 544, 2063, 1, 0, 0, 0, 546, 2067, 1, 0, 0, 0, 548, 2071, 1, 0, 0, 0, 550, 2075, 1, 0, 0, 0, 552, 2079, 1, 0, 0, 0, 554, 2083, 1, 0, 0, 0, 556, 2087, 1, 0, 0, 0, 558, 2091, 1, 0, 0, 0, 560, 2095, 1, 0, 0, 0, 562, 2099, 1, 0, 0, 0, 564, 2103, 1, 0, 0, 0, 566, 2107, 1, 0, 0, 0, 568, 2111, 1, 0, 0, 0, 570, 2115, 1, 0, 0, 0, 572, 2119, 1, 0, 0, 0, 574, 2123, 1, 0, 0, 0, 576, 2127, 1, 0, 0, 0, 578, 2131, 1, 0, 0, 0, 580, 2135, 1, 0, 0, 0, 582, 2139, 1, 0, 0, 0, 584, 2143, 1, 0, 0, 0, 586, 2147, 1, 0, 0, 0, 588, 2151, 1, 0, 0, 0, 590, 2155, 1, 0, 0, 0, 592, 2159, 1, 0, 0, 0, 594, 2163, 1, 0, 0, 0, 596, 2167, 1, 0, 0, 0, 598, 2171, 1, 0, 0, 0, 600, 2175, 1, 0, 0, 0, 602, 2179, 1, 0, 0, 0, 604, 2183, 1, 0, 0, 0, 606, 2187, 1, 0, 0, 0, 608, 2191, 1, 0, 0, 0, 610, 2195, 1, 0, 0, 0, 612, 2199, 1, 0, 0, 0, 614, 2203, 1, 0, 0, 0, 616, 2207, 1, 0, 0, 0, 618, 2211, 1, 0, 0, 0, 620, 2215, 1, 0, 0, 0, 622, 2219, 1, 0, 0, 0, 624, 2225, 1, 0, 0, 0, 626, 2229, 1, 0, 0, 0, 628, 2233, 1, 0, 0, 0, 630, 2237, 1, 0, 0, 0, 632, 633, 5, 35, 0, 0, 633, 634, 5, 33, 0, 0, 634, 638, 1, 0, 0, 0, 635, 637, 8, 0, 0, 0, 636, 635, 1, 0, 0, 0, 637, 640, 1, 0, 0, 0, 638, 636, 1, 0, 0, 0, 638, 639, 1, 0, 0, 0, 639, 5, 1, 0, 0, 0, 640, 638, 1, 0, 0, 0, 641, 642, 5, 47, 0, 0, 642, 643, 5, 42, 0, 0, 643, 648, 1, 0, 0, 0, 644, 647, 3, 6, 1, 0, 645, 647, 9, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 645, 1, 0, 0, 0, 647, 650, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, 651, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 651, 652, 5, 42, 0, 0, 652, 653, 5, 47, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 6, 1, 0, 0, 655, 7, 1, 0, 0, 0, 656, 657, 5, 47, 0, 0, 657, 658, 5, 47, 0, 0, 658, 662, 1, 0, 0, 0, 659, 661, 8, 0, 0, 0, 660, 659, 1, 0, 0, 0, 661, 664, 1, 0, 0, 0, 662, 660, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 665, 1, 0, 0, 0, 664, 662, 1, 0, 0, 0, 665, 666, 6, 2, 0, 0, 666, 9, 1, 0, 0, 0, 667, 668, 7, 1, 0, 0, 668, 669, 1, 0, 0, 0, 669, 670, 6, 3, 0, 0, 670, 11, 1, 0, 0, 0, 671, 677, 5, 10, 0, 0, 672, 674, 5, 13, 0, 0, 673, 675, 5, 10, 0, 0, 674, 673, 1, 0, 0, 0, 674, 675, 1, 0, 0, 0, 675, 677, 1, 0, 0, 0, 676, 671, 1, 0, 0, 0, 676, 672, 1, 0, 0, 0, 677, 13, 1, 0, 0, 0, 678, 682, 3, 6, 1, 0, 679, 682, 3, 8, 2, 0, 680, 682, 3, 10, 3, 0, 681, 678, 1, 0, 0, 0, 681, 679, 1, 0, 0, 0, 681, 680, 1, 0, 0, 0, 682, 15, 1, 0, 0, 0, 683, 684, 5, 46, 0, 0, 684, 685, 5, 46, 0, 0, 685, 686, 5, 46, 0, 0, 686, 17, 1, 0, 0, 0, 687, 688, 5, 46, 0, 0, 688, 19, 1, 0, 0, 0, 689, 690, 5, 44, 0, 0, 690, 21, 1, 0, 0, 0, 691, 692, 5, 40, 0, 0, 692, 693, 1, 0, 0, 0, 693, 694, 6, 9, 1, 0, 694, 23, 1, 0, 0, 0, 695, 696, 5, 41, 0, 0, 696, 25, 1, 0, 0, 0, 697, 698, 5, 91, 0, 0, 698, 699, 1, 0, 0, 0, 699, 700, 6, 11, 1, 0, 700, 27, 1, 0, 0, 0, 701, 702, 5, 93, 0, 0, 702, 29, 1, 0, 0, 0, 703, 704, 5, 123, 0, 0, 704, 705, 1, 0, 0, 0, 705, 706, 6, 13, 2, 0, 706, 31, 1, 0, 0, 0, 707, 708, 5, 125, 0, 0, 708, 709, 1, 0, 0, 0, 709, 710, 6, 14, 3, 0, 710, 33, 1, 0, 0, 0, 711, 712, 5, 42, 0, 0, 712, 35, 1, 0, 0, 0, 713, 714, 5, 37, 0, 0, 714, 37, 1, 0, 0, 0, 715, 716, 5, 47, 0, 0, 716, 39, 1, 0, 0, 0, 717, 718, 5, 43, 0, 0, 718, 41, 1, 0, 0, 0, 719, 720, 5, 45, 0, 0, 720, 43, 1, 0, 0, 0, 721, 722, 5, 43, 0, 0, 722, 723, 5, 43, 0, 0, 723, 45, 1, 0, 0, 0, 724, 725, 5, 45, 0, 0, 725, 726, 5, 45, 0, 0, 726, 47, 1, 0, 0, 0, 727, 728, 5, 38, 0, 0, 728, 729, 5, 38, 0, 0, 729, 49, 1, 0, 0, 0, 730, 731, 5, 124, 0, 0, 731, 732, 5, 124, 0, 0, 732, 51, 1, 0, 0, 0, 733, 734, 5, 33, 0, 0, 734, 735, 3, 14, 5, 0, 735, 53, 1, 0, 0, 0, 736, 737, 5, 33, 0, 0, 737, 55, 1, 0, 0, 0, 738, 739, 5, 58, 0, 0, 739, 57, 1, 0, 0, 0, 740, 741, 5, 59, 0, 0, 741, 59, 1, 0, 0, 0, 742, 743, 5, 61, 0, 0, 743, 61, 1, 0, 0, 0, 744, 745, 5, 43, 0, 0, 745, 746, 5, 61, 0, 0, 746, 63, 1, 0, 0, 0, 747, 748, 5, 45, 0, 0, 748, 749, 5, 61, 0, 0, 749, 65, 1, 0, 0, 0, 750, 751, 5, 42, 0, 0, 751, 752, 5, 61, 0, 0, 752, 67, 1, 0, 0, 0, 753, 754, 5, 47, 0, 0, 754, 755, 5, 61, 0, 0, 755, 69, 1, 0, 0, 0, 756, 757, 5, 37, 0, 0, 757, 758, 5, 61, 0, 0, 758, 71, 1, 0, 0, 0, 759, 760, 5, 45, 0, 0, 760, 761, 5, 62, 0, 0, 761, 73, 1, 0, 0, 0, 762, 763, 5, 61, 0, 0, 763, 764, 5, 62, 0, 0, 764, 75, 1, 0, 0, 0, 765, 766, 5, 46, 0, 0, 766, 767, 5, 46, 0, 0, 767, 77, 1, 0, 0, 0, 768, 769, 5, 58, 0, 0, 769, 770, 5, 58, 0, 0, 770, 79, 1, 0, 0, 0, 771, 772, 5, 59, 0, 0, 772, 773, 5, 59, 0, 0, 773, 81, 1, 0, 0, 0, 774, 775, 5, 35, 0, 0, 775, 83, 1, 0, 0, 0, 776, 777, 5, 64, 0, 0, 777, 85, 1, 0, 0, 0, 778, 781, 5, 64, 0, 0, 779, 782, 3, 14, 5, 0, 780, 782, 3, 12, 4, 0, 781, 779, 1, 0, 0, 0, 781, 780, 1, 0, 0, 0, 782, 87, 1, 0, 0, 0, 783, 786, 3, 14, 5, 0, 784, 786, 3, 12, 4, 0, 785, 783, 1, 0, 0, 0, 785, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 788, 5, 64, 0, 0, 788, 89, 1, 0, 0, 0, 789, 792, 3, 14, 5, 0, 790, 792, 3, 12, 4, 0, 791, 789, 1, 0, 0, 0, 791, 790, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 796, 5, 64, 0, 0, 794, 797, 3, 14, 5, 0, 795, 797, 3, 12, 4, 0, 796, 794, 1, 0, 0, 0, 796, 795, 1, 0, 0, 0, 797, 91, 1, 0, 0, 0, 798, 799, 5, 63, 0, 0, 799, 800, 3, 14, 5, 0, 800, 93, 1, 0, 0, 0, 801, 802, 5, 63, 0, 0, 802, 95, 1, 0, 0, 0, 803, 804, 5, 60, 0, 0, 804, 97, 1, 0, 0, 0, 805, 806, 5, 62, 0, 0, 806, 99, 1, 0, 0, 0, 807, 808, 5, 60, 0, 0, 808, 809, 5, 61, 0, 0, 809, 101, 1, 0, 0, 0, 810, 811, 5, 62, 0, 0, 811, 812, 5, 61, 0, 0, 812, 103, 1, 0, 0, 0, 813, 814, 5, 33, 0, 0, 814, 815, 5, 61, 0, 0, 815, 105, 1, 0, 0, 0, 816, 817, 5, 33, 0, 0, 817, 818, 5, 61, 0, 0, 818, 819, 5, 61, 0, 0, 819, 107, 1, 0, 0, 0, 820, 821, 5, 97, 0, 0, 821, 822, 5, 115, 0, 0, 822, 823, 5, 63, 0, 0, 823, 109, 1, 0, 0, 0, 824, 825, 5, 61, 0, 0, 825, 826, 5, 61, 0, 0, 826, 111, 1, 0, 0, 0, 827, 828, 5, 61, 0, 0, 828, 829, 5, 61, 0, 0, 829, 830, 5, 61, 0, 0, 830, 113, 1, 0, 0, 0, 831, 832, 5, 39, 0, 0, 832, 115, 1, 0, 0, 0, 833, 834, 5, 38, 0, 0, 834, 117, 1, 0, 0, 0, 835, 836, 5, 114, 0, 0, 836, 837, 5, 101, 0, 0, 837, 838, 5, 116, 0, 0, 838, 839, 5, 117, 0, 0, 839, 840, 5, 114, 0, 0, 840, 841, 5, 110, 0, 0, 841, 842, 5, 64, 0, 0, 842, 843, 1, 0, 0, 0, 843, 844, 3, 318, 157, 0, 844, 119, 1, 0, 0, 0, 845, 846, 5, 99, 0, 0, 846, 847, 5, 111, 0, 0, 847, 848, 5, 110, 0, 0, 848, 849, 5, 116, 0, 0, 849, 850, 5, 105, 0, 0, 850, 851, 5, 110, 0, 0, 851, 852, 5, 117, 0, 0, 852, 853, 5, 101, 0, 0, 853, 854, 5, 64, 0, 0, 854, 855, 1, 0, 0, 0, 855, 856, 3, 318, 157, 0, 856, 121, 1, 0, 0, 0, 857, 858, 5, 98, 0, 0, 858, 859, 5, 114, 0, 0, 859, 860, 5, 101, 0, 0, 860, 861, 5, 97, 0, 0, 861, 862, 5, 107, 0, 0, 862, 863, 5, 64, 0, 0, 863, 864, 1, 0, 0, 0, 864, 865, 3, 318, 157, 0, 865, 123, 1, 0, 0, 0, 866, 867, 5, 116, 0, 0, 867, 868, 5, 104, 0, 0, 868, 869, 5, 105, 0, 0, 869, 870, 5, 115, 0, 0, 870, 871, 5, 64, 0, 0, 871, 872, 1, 0, 0, 0, 872, 873, 3, 318, 157, 0, 873, 125, 1, 0, 0, 0, 874, 875, 5, 115, 0, 0, 875, 876, 5, 117, 0, 0, 876, 877, 5, 112, 0, 0, 877, 878, 5, 101, 0, 0, 878, 879, 5, 114, 0, 0, 879, 880, 5, 64, 0, 0, 880, 881, 1, 0, 0, 0, 881, 882, 3, 318, 157, 0, 882, 127, 1, 0, 0, 0, 883, 884, 5, 102, 0, 0, 884, 885, 5, 105, 0, 0, 885, 886, 5, 108, 0, 0, 886, 887, 5, 101, 0, 0, 887, 129, 1, 0, 0, 0, 888, 889, 5, 102, 0, 0, 889, 890, 5, 105, 0, 0, 890, 891, 5, 101, 0, 0, 891, 892, 5, 108, 0, 0, 892, 893, 5, 100, 0, 0, 893, 131, 1, 0, 0, 0, 894, 895, 5, 112, 0, 0, 895, 896, 5, 114, 0, 0, 896, 897, 5, 111, 0, 0, 897, 898, 5, 112, 0, 0, 898, 899, 5, 101, 0, 0, 899, 900, 5, 114, 0, 0, 900, 901, 5, 116, 0, 0, 901, 902, 5, 121, 0, 0, 902, 133, 1, 0, 0, 0, 903, 904, 5, 103, 0, 0, 904, 905, 5, 101, 0, 0, 905, 906, 5, 116, 0, 0, 906, 135, 1, 0, 0, 0, 907, 908, 5, 115, 0, 0, 908, 909, 5, 101, 0, 0, 909, 910, 5, 116, 0, 0, 910, 137, 1, 0, 0, 0, 911, 912, 5, 114, 0, 0, 912, 913, 5, 101, 0, 0, 913, 914, 5, 99, 0, 0, 914, 915, 5, 101, 0, 0, 915, 916, 5, 105, 0, 0, 916, 917, 5, 118, 0, 0, 917, 918, 5, 101, 0, 0, 918, 919, 5, 114, 0, 0, 919, 139, 1, 0, 0, 0, 920, 921, 5, 112, 0, 0, 921, 922, 5, 97, 0, 0, 922, 923, 5, 114, 0, 0, 923, 924, 5, 97, 0, 0, 924, 925, 5, 109, 0, 0, 925, 141, 1, 0, 0, 0, 926, 927, 5, 115, 0, 0, 927, 928, 5, 101, 0, 0, 928, 929, 5, 116, 0, 0, 929, 930, 5, 112, 0, 0, 930, 931, 5, 97, 0, 0, 931, 932, 5, 114, 0, 0, 932, 933, 5, 97, 0, 0, 933, 934, 5, 109, 0, 0, 934, 143, 1, 0, 0, 0, 935, 936, 5, 100, 0, 0, 936, 937, 5, 101, 0, 0, 937, 938, 5, 108, 0, 0, 938, 939, 5, 101, 0, 0, 939, 940, 5, 103, 0, 0, 940, 941, 5, 97, 0, 0, 941, 942, 5, 116, 0, 0, 942, 943, 5, 101, 0, 0, 943, 145, 1, 0, 0, 0, 944, 945, 5, 112, 0, 0, 945, 946, 5, 97, 0, 0, 946, 947, 5, 99, 0, 0, 947, 948, 5, 107, 0, 0, 948, 949, 5, 97, 0, 0, 949, 950, 5, 103, 0, 0, 950, 951, 5, 101, 0, 0, 951, 147, 1, 0, 0, 0, 952, 953, 5, 105, 0, 0, 953, 954, 5, 109, 0, 0, 954, 955, 5, 112, 0, 0, 955, 956, 5, 111, 0, 0, 956, 957, 5, 114, 0, 0, 957, 958, 5, 116, 0, 0, 958, 149, 1, 0, 0, 0, 959, 960, 5, 99, 0, 0, 960, 961, 5, 108, 0, 0, 961, 962, 5, 97, 0, 0, 962, 963, 5, 115, 0, 0, 963, 964, 5, 115, 0, 0, 964, 151, 1, 0, 0, 0, 965, 966, 5, 105, 0, 0, 966, 967, 5, 110, 0, 0, 967, 968, 5, 116, 0, 0, 968, 969, 5, 101, 0, 0, 969, 970, 5, 114, 0, 0, 970, 971, 5, 102, 0, 0, 971, 972, 5, 97, 0, 0, 972, 973, 5, 99, 0, 0, 973, 974, 5, 101, 0, 0, 974, 153, 1, 0, 0, 0, 975, 976, 5, 102, 0, 0, 976, 977, 5, 117, 0, 0, 977, 978, 5, 110, 0, 0, 978, 155, 1, 0, 0, 0, 979, 980, 5, 111, 0, 0, 980, 981, 5, 98, 0, 0, 981, 982, 5, 106, 0, 0, 982, 983, 5, 101, 0, 0, 983, 984, 5, 99, 0, 0, 984, 985, 5, 116, 0, 0, 985, 157, 1, 0, 0, 0, 986, 987, 5, 118, 0, 0, 987, 988, 5, 97, 0, 0, 988, 989, 5, 108, 0, 0, 989, 159, 1, 0, 0, 0, 990, 991, 5, 118, 0, 0, 991, 992, 5, 97, 0, 0, 992, 993, 5, 114, 0, 0, 993, 161, 1, 0, 0, 0, 994, 995, 5, 116, 0, 0, 995, 996, 5, 121, 0, 0, 996, 997, 5, 112, 0, 0, 997, 998, 5, 101, 0, 0, 998, 999, 5, 97, 0, 0, 999, 1000, 5, 108, 0, 0, 1000, 1001, 5, 105, 0, 0, 1001, 1002, 5, 97, 0, 0, 1002, 1003, 5, 115, 0, 0, 1003, 163, 1, 0, 0, 0, 1004, 1005, 5, 99, 0, 0, 1005, 1006, 5, 111, 0, 0, 1006, 1007, 5, 110, 0, 0, 1007, 1008, 5, 115, 0, 0, 1008, 1009, 5, 116, 0, 0, 1009, 1010, 5, 114, 0, 0, 1010, 1011, 5, 117, 0, 0, 1011, 1012, 5, 99, 0, 0, 1012, 1013, 5, 116, 0, 0, 1013, 1014, 5, 111, 0, 0, 1014, 1015, 5, 114, 0, 0, 1015, 165, 1, 0, 0, 0, 1016, 1017, 5, 98, 0, 0, 1017, 1018, 5, 121, 0, 0, 1018, 167, 1, 0, 0, 0, 1019, 1020, 5, 99, 0, 0, 1020, 1021, 5, 111, 0, 0, 1021, 1022, 5, 109, 0, 0, 1022, 1023, 5, 112, 0, 0, 1023, 1024, 5, 97, 0, 0, 1024, 1025, 5, 110, 0, 0, 1025, 1026, 5, 105, 0, 0, 1026, 1027, 5, 111, 0, 0, 1027, 1028, 5, 110, 0, 0, 1028, 169, 1, 0, 0, 0, 1029, 1030, 5, 105, 0, 0, 1030, 1031, 5, 110, 0, 0, 1031, 1032, 5, 105, 0, 0, 1032, 1033, 5, 116, 0, 0, 1033, 171, 1, 0, 0, 0, 1034, 1035, 5, 116, 0, 0, 1035, 1036, 5, 104, 0, 0, 1036, 1037, 5, 105, 0, 0, 1037, 1038, 5, 115, 0, 0, 1038, 173, 1, 0, 0, 0, 1039, 1040, 5, 115, 0, 0, 1040, 1041, 5, 117, 0, 0, 1041, 1042, 5, 112, 0, 0, 1042, 1043, 5, 101, 0, 0, 1043, 1044, 5, 114, 0, 0, 1044, 175, 1, 0, 0, 0, 1045, 1046, 5, 116, 0, 0, 1046, 1047, 5, 121, 0, 0, 1047, 1048, 5, 112, 0, 0, 1048, 1049, 5, 101, 0, 0, 1049, 1050, 5, 111, 0, 0, 1050, 1051, 5, 102, 0, 0, 1051, 177, 1, 0, 0, 0, 1052, 1053, 5, 119, 0, 0, 1053, 1054, 5, 104, 0, 0, 1054, 1055, 5, 101, 0, 0, 1055, 1056, 5, 114, 0, 0, 1056, 1057, 5, 101, 0, 0, 1057, 179, 1, 0, 0, 0, 1058, 1059, 5, 105, 0, 0, 1059, 1060, 5, 102, 0, 0, 1060, 181, 1, 0, 0, 0, 1061, 1062, 5, 101, 0, 0, 1062, 1063, 5, 108, 0, 0, 1063, 1064, 5, 115, 0, 0, 1064, 1065, 5, 101, 0, 0, 1065, 183, 1, 0, 0, 0, 1066, 1067, 5, 119, 0, 0, 1067, 1068, 5, 104, 0, 0, 1068, 1069, 5, 101, 0, 0, 1069, 1070, 5, 110, 0, 0, 1070, 185, 1, 0, 0, 0, 1071, 1072, 5, 116, 0, 0, 1072, 1073, 5, 114, 0, 0, 1073, 1074, 5, 121, 0, 0, 1074, 187, 1, 0, 0, 0, 1075, 1076, 5, 99, 0, 0, 1076, 1077, 5, 97, 0, 0, 1077, 1078, 5, 116, 0, 0, 1078, 1079, 5, 99, 0, 0, 1079, 1080, 5, 104, 0, 0, 1080, 189, 1, 0, 0, 0, 1081, 1082, 5, 102, 0, 0, 1082, 1083, 5, 105, 0, 0, 1083, 1084, 5, 110, 0, 0, 1084, 1085, 5, 97, 0, 0, 1085, 1086, 5, 108, 0, 0, 1086, 1087, 5, 108, 0, 0, 1087, 1088, 5, 121, 0, 0, 1088, 191, 1, 0, 0, 0, 1089, 1090, 5, 102, 0, 0, 1090, 1091, 5, 111, 0, 0, 1091, 1092, 5, 114, 0, 0, 1092, 193, 1, 0, 0, 0, 1093, 1094, 5, 100, 0, 0, 1094, 1095, 5, 111, 0, 0, 1095, 195, 1, 0, 0, 0, 1096, 1097, 5, 119, 0, 0, 1097, 1098, 5, 104, 0, 0, 1098, 1099, 5, 105, 0, 0, 1099, 1100, 5, 108, 0, 0, 1100, 1101, 5, 101, 0, 0, 1101, 197, 1, 0, 0, 0, 1102, 1103, 5, 116, 0, 0, 1103, 1104, 5, 104, 0, 0, 1104, 1105, 5, 114, 0, 0, 1105, 1106, 5, 111, 0, 0, 1106, 1107, 5, 119, 0, 0, 1107, 199, 1, 0, 0, 0, 1108, 1109, 5, 114, 0, 0, 1109, 1110, 5, 101, 0, 0, 1110, 1111, 5, 116, 0, 0, 1111, 1112, 5, 117, 0, 0, 1112, 1113, 5, 114, 0, 0, 1113, 1114, 5, 110, 0, 0, 1114, 201, 1, 0, 0, 0, 1115, 1116, 5, 99, 0, 0, 1116, 1117, 5, 111, 0, 0, 1117, 1118, 5, 110, 0, 0, 1118, 1119, 5, 116, 0, 0, 1119, 1120, 5, 105, 0, 0, 1120, 1121, 5, 110, 0, 0, 1121, 1122, 5, 117, 0, 0, 1122, 1123, 5, 101, 0, 0, 1123, 203, 1, 0, 0, 0, 1124, 1125, 5, 98, 0, 0, 1125, 1126, 5, 114, 0, 0, 1126, 1127, 5, 101, 0, 0, 1127, 1128, 5, 97, 0, 0, 1128, 1129, 5, 107, 0, 0, 1129, 205, 1, 0, 0, 0, 1130, 1131, 5, 97, 0, 0, 1131, 1132, 5, 115, 0, 0, 1132, 207, 1, 0, 0, 0, 1133, 1134, 5, 105, 0, 0, 1134, 1135, 5, 115, 0, 0, 1135, 209, 1, 0, 0, 0, 1136, 1137, 5, 105, 0, 0, 1137, 1138, 5, 110, 0, 0, 1138, 211, 1, 0, 0, 0, 1139, 1140, 5, 33, 0, 0, 1140, 1141, 5, 105, 0, 0, 1141, 1142, 5, 115, 0, 0, 1142, 1145, 1, 0, 0, 0, 1143, 1146, 3, 14, 5, 0, 1144, 1146, 3, 12, 4, 0, 1145, 1143, 1, 0, 0, 0, 1145, 1144, 1, 0, 0, 0, 1146, 213, 1, 0, 0, 0, 1147, 1148, 5, 33, 0, 0, 1148, 1149, 5, 105, 0, 0, 1149, 1150, 5, 110, 0, 0, 1150, 1153, 1, 0, 0, 0, 1151, 1154, 3, 14, 5, 0, 1152, 1154, 3, 12, 4, 0, 1153, 1151, 1, 0, 0, 0, 1153, 1152, 1, 0, 0, 0, 1154, 215, 1, 0, 0, 0, 1155, 1156, 5, 111, 0, 0, 1156, 1157, 5, 117, 0, 0, 1157, 1158, 5, 116, 0, 0, 1158, 217, 1, 0, 0, 0, 1159, 1160, 5, 100, 0, 0, 1160, 1161, 5, 121, 0, 0, 1161, 1162, 5, 110, 0, 0, 1162, 1163, 5, 97, 0, 0, 1163, 1164, 5, 109, 0, 0, 1164, 1165, 5, 105, 0, 0, 1165, 1166, 5, 99, 0, 0, 1166, 219, 1, 0, 0, 0, 1167, 1168, 5, 112, 0, 0, 1168, 1169, 5, 117, 0, 0, 1169, 1170, 5, 98, 0, 0, 1170, 1171, 5, 108, 0, 0, 1171, 1172, 5, 105, 0, 0, 1172, 1173, 5, 99, 0, 0, 1173, 221, 1, 0, 0, 0, 1174, 1175, 5, 112, 0, 0, 1175, 1176, 5, 114, 0, 0, 1176, 1177, 5, 105, 0, 0, 1177, 1178, 5, 118, 0, 0, 1178, 1179, 5, 97, 0, 0, 1179, 1180, 5, 116, 0, 0, 1180, 1181, 5, 101, 0, 0, 1181, 223, 1, 0, 0, 0, 1182, 1183, 5, 112, 0, 0, 1183, 1184, 5, 114, 0, 0, 1184, 1185, 5, 111, 0, 0, 1185, 1186, 5, 116, 0, 0, 1186, 1187, 5, 101, 0, 0, 1187, 1188, 5, 99, 0, 0, 1188, 1189, 5, 116, 0, 0, 1189, 1190, 5, 101, 0, 0, 1190, 1191, 5, 100, 0, 0, 1191, 225, 1, 0, 0, 0, 1192, 1193, 5, 105, 0, 0, 1193, 1194, 5, 110, 0, 0, 1194, 1195, 5, 116, 0, 0, 1195, 1196, 5, 101, 0, 0, 1196, 1197, 5, 114, 0, 0, 1197, 1198, 5, 110, 0, 0, 1198, 1199, 5, 97, 0, 0, 1199, 1200, 5, 108, 0, 0, 1200, 227, 1, 0, 0, 0, 1201, 1202, 5, 101, 0, 0, 1202, 1203, 5, 110, 0, 0, 1203, 1204, 5, 117, 0, 0, 1204, 1205, 5, 109, 0, 0, 1205, 229, 1, 0, 0, 0, 1206, 1207, 5, 115, 0, 0, 1207, 1208, 5, 101, 0, 0, 1208, 1209, 5, 97, 0, 0, 1209, 1210, 5, 108, 0, 0, 1210, 1211, 5, 101, 0, 0, 1211, 1212, 5, 100, 0, 0, 1212, 231, 1, 0, 0, 0, 1213, 1214, 5, 97, 0, 0, 1214, 1215, 5, 110, 0, 0, 1215, 1216, 5, 110, 0, 0, 1216, 1217, 5, 111, 0, 0, 1217, 1218, 5, 116, 0, 0, 1218, 1219, 5, 97, 0, 0, 1219, 1220, 5, 116, 0, 0, 1220, 1221, 5, 105, 0, 0, 1221, 1222, 5, 111, 0, 0, 1222, 1223, 5, 110, 0, 0, 1223, 233, 1, 0, 0, 0, 1224, 1225, 5, 100, 0, 0, 1225, 1226, 5, 97, 0, 0, 1226, 1227, 5, 116, 0, 0, 1227, 1228, 5, 97, 0, 0, 1228, 235, 1, 0, 0, 0, 1229, 1230, 5, 105, 0, 0, 1230, 1231, 5, 110, 0, 0, 1231, 1232, 5, 110, 0, 0, 1232, 1233, 5, 101, 0, 0, 1233, 1234, 5, 114, 0, 0, 1234, 237, 1, 0, 0, 0, 1235, 1236, 5, 118, 0, 0, 1236, 1237, 5, 97, 0, 0, 1237, 1238, 5, 108, 0, 0, 1238, 1239, 5, 117, 0, 0, 1239, 1240, 5, 101, 0, 0, 1240, 239, 1, 0, 0, 0, 1241, 1242, 5, 116, 0, 0, 1242, 1243, 5, 97, 0, 0, 1243, 1244, 5, 105, 0, 0, 1244, 1245, 5, 108, 0, 0, 1245, 1246, 5, 114, 0, 0, 1246, 1247, 5, 101, 0, 0, 1247, 1248, 5, 99, 0, 0, 1248, 241, 1, 0, 0, 0, 1249, 1250, 5, 111, 0, 0, 1250, 1251, 5, 112, 0, 0, 1251, 1252, 5, 101, 0, 0, 1252, 1253, 5, 114, 0, 0, 1253, 1254, 5, 97, 0, 0, 1254, 1255, 5, 116, 0, 0, 1255, 1256, 5, 111, 0, 0, 1256, 1257, 5, 114, 0, 0, 1257, 243, 1, 0, 0, 0, 1258, 1259, 5, 105, 0, 0, 1259, 1260, 5, 110, 0, 0, 1260, 1261, 5, 108, 0, 0, 1261, 1262, 5, 105, 0, 0, 1262, 1263, 5, 110, 0, 0, 1263, 1264, 5, 101, 0, 0, 1264, 245, 1, 0, 0, 0, 1265, 1266, 5, 105, 0, 0, 1266, 1267, 5, 110, 0, 0, 1267, 1268, 5, 102, 0, 0, 1268, 1269, 5, 105, 0, 0, 1269, 1270, 5, 120, 0, 0, 1270, 247, 1, 0, 0, 0, 1271, 1272, 5, 101, 0, 0, 1272, 1273, 5, 120, 0, 0, 1273, 1274, 5, 116, 0, 0, 1274, 1275, 5, 101, 0, 0, 1275, 1276, 5, 114, 0, 0, 1276, 1277, 5, 110, 0, 0, 1277, 1278, 5, 97, 0, 0, 1278, 1279, 5, 108, 0, 0, 1279, 249, 1, 0, 0, 0, 1280, 1281, 5, 115, 0, 0, 1281, 1282, 5, 117, 0, 0, 1282, 1283, 5, 115, 0, 0, 1283, 1284, 5, 112, 0, 0, 1284, 1285, 5, 101, 0, 0, 1285, 1286, 5, 110, 0, 0, 1286, 1287, 5, 100, 0, 0, 1287, 251, 1, 0, 0, 0, 1288, 1289, 5, 111, 0, 0, 1289, 1290, 5, 118, 0, 0, 1290, 1291, 5, 101, 0, 0, 1291, 1292, 5, 114, 0, 0, 1292, 1293, 5, 114, 0, 0, 1293, 1294, 5, 105, 0, 0, 1294, 1295, 5, 100, 0, 0, 1295, 1296, 5, 101, 0, 0, 1296, 253, 1, 0, 0, 0, 1297, 1298, 5, 97, 0, 0, 1298, 1299, 5, 98, 0, 0, 1299, 1300, 5, 115, 0, 0, 1300, 1301, 5, 116, 0, 0, 1301, 1302, 5, 114, 0, 0, 1302, 1303, 5, 97, 0, 0, 1303, 1304, 5, 99, 0, 0, 1304, 1305, 5, 116, 0, 0, 1305, 255, 1, 0, 0, 0, 1306, 1307, 5, 102, 0, 0, 1307, 1308, 5, 105, 0, 0, 1308, 1309, 5, 110, 0, 0, 1309, 1310, 5, 97, 0, 0, 1310, 1311, 5, 108, 0, 0, 1311, 257, 1, 0, 0, 0, 1312, 1313, 5, 111, 0, 0, 1313, 1314, 5, 112, 0, 0, 1314, 1315, 5, 101, 0, 0, 1315, 1316, 5, 110, 0, 0, 1316, 259, 1, 0, 0, 0, 1317, 1318, 5, 99, 0, 0, 1318, 1319, 5, 111, 0, 0, 1319, 1320, 5, 110, 0, 0, 1320, 1321, 5, 115, 0, 0, 1321, 1322, 5, 116, 0, 0, 1322, 261, 1, 0, 0, 0, 1323, 1324, 5, 108, 0, 0, 1324, 1325, 5, 97, 0, 0, 1325, 1326, 5, 116, 0, 0, 1326, 1327, 5, 101, 0, 0, 1327, 1328, 5, 105, 0, 0, 1328, 1329, 5, 110, 0, 0, 1329, 1330, 5, 105, 0, 0, 1330, 1331, 5, 116, 0, 0, 1331, 263, 1, 0, 0, 0, 1332, 1333, 5, 118, 0, 0, 1333, 1334, 5, 97, 0, 0, 1334, 1335, 5, 114, 0, 0, 1335, 1336, 5, 97, 0, 0, 1336, 1337, 5, 114, 0, 0, 1337, 1338, 5, 103, 0, 0, 1338, 265, 1, 0, 0, 0, 1339, 1340, 5, 110, 0, 0, 1340, 1341, 5, 111, 0, 0, 1341, 1342, 5, 105, 0, 0, 1342, 1343, 5, 110, 0, 0, 1343, 1344, 5, 108, 0, 0, 1344, 1345, 5, 105, 0, 0, 1345, 1346, 5, 110, 0, 0, 1346, 1347, 5, 101, 0, 0, 1347, 267, 1, 0, 0, 0, 1348, 1349, 5, 99, 0, 0, 1349, 1350, 5, 114, 0, 0, 1350, 1351, 5, 111, 0, 0, 1351, 1352, 5, 115, 0, 0, 1352, 1353, 5, 115, 0, 0, 1353, 1354, 5, 105, 0, 0, 1354, 1355, 5, 110, 0, 0, 1355, 1356, 5, 108, 0, 0, 1356, 1357, 5, 105, 0, 0, 1357, 1358, 5, 110, 0, 0, 1358, 1359, 5, 101, 0, 0, 1359, 269, 1, 0, 0, 0, 1360, 1361, 5, 114, 0, 0, 1361, 1362, 5, 101, 0, 0, 1362, 1363, 5, 105, 0, 0, 1363, 1364, 5, 102, 0, 0, 1364, 1365, 5, 105, 0, 0, 1365, 1366, 5, 101, 0, 0, 1366, 1367, 5, 100, 0, 0, 1367, 271, 1, 0, 0, 0, 1368, 1369, 5, 101, 0, 0, 1369, 1370, 5, 120, 0, 0, 1370, 1371, 5, 112, 0, 0, 1371, 1372, 5, 101, 0, 0, 1372, 1373, 5, 99, 0, 0, 1373, 1374, 5, 116, 0, 0, 1374, 273, 1, 0, 0, 0, 1375, 1376, 5, 97, 0, 0, 1376, 1377, 5, 99, 0, 0, 1377, 1378, 5, 116, 0, 0, 1378, 1379, 5, 117, 0, 0, 1379, 1380, 5, 97, 0, 0, 1380, 1381, 5, 108, 0, 0, 1381, 275, 1, 0, 0, 0, 1382, 1383, 2, 48, 57, 0, 1383, 277, 1, 0, 0, 0, 1384, 1385, 2, 49, 57, 0, 1385, 279, 1, 0, 0, 0, 1386, 1389, 3, 276, 136, 0, 1387, 1389, 5, 95, 0, 0, 1388, 1386, 1, 0, 0, 0, 1388, 1387, 1, 0, 0, 0, 1389, 281, 1, 0, 0, 0, 1390, 1394, 3, 276, 136, 0, 1391, 1393, 3, 280, 138, 0, 1392, 1391, 1, 0, 0, 0, 1393, 1396, 1, 0, 0, 0, 1394, 1392, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, 0, 1395, 1397, 1, 0, 0, 0, 1396, 1394, 1, 0, 0, 0, 1397, 1398, 3, 276, 136, 0, 1398, 1401, 1, 0, 0, 0, 1399, 1401, 3, 276, 136, 0, 1400, 1390, 1, 0, 0, 0, 1400, 1399, 1, 0, 0, 0, 1401, 283, 1, 0, 0, 0, 1402, 1404, 7, 2, 0, 0, 1403, 1405, 7, 3, 0, 0, 1404, 1403, 1, 0, 0, 0, 1404, 1405, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1407, 3, 282, 139, 0, 1407, 285, 1, 0, 0, 0, 1408, 1411, 3, 288, 142, 0, 1409, 1411, 3, 290, 143, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1409, 1, 0, 0, 0, 1411, 287, 1, 0, 0, 0, 1412, 1413, 3, 290, 143, 0, 1413, 1414, 7, 4, 0, 0, 1414, 1419, 1, 0, 0, 0, 1415, 1416, 3, 282, 139, 0, 1416, 1417, 7, 4, 0, 0, 1417, 1419, 1, 0, 0, 0, 1418, 1412, 1, 0, 0, 0, 1418, 1415, 1, 0, 0, 0, 1419, 289, 1, 0, 0, 0, 1420, 1422, 3, 282, 139, 0, 1421, 1420, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 1423, 1, 0, 0, 0, 1423, 1424, 5, 46, 0, 0, 1424, 1426, 3, 282, 139, 0, 1425, 1427, 3, 284, 140, 0, 1426, 1425, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427, 1432, 1, 0, 0, 0, 1428, 1429, 3, 282, 139, 0, 1429, 1430, 3, 284, 140, 0, 1430, 1432, 1, 0, 0, 0, 1431, 1421, 1, 0, 0, 0, 1431, 1428, 1, 0, 0, 0, 1432, 291, 1, 0, 0, 0, 1433, 1437, 3, 278, 137, 0, 1434, 1436, 3, 280, 138, 0, 1435, 1434, 1, 0, 0, 0, 1436, 1439, 1, 0, 0, 0, 1437, 1435, 1, 0, 0, 0, 1437, 1438, 1, 0, 0, 0, 1438, 1440, 1, 0, 0, 0, 1439, 1437, 1, 0, 0, 0, 1440, 1441, 3, 276, 136, 0, 1441, 1444, 1, 0, 0, 0, 1442, 1444, 3, 276, 136, 0, 1443, 1433, 1, 0, 0, 0, 1443, 1442, 1, 0, 0, 0, 1444, 293, 1, 0, 0, 0, 1445, 1446, 7, 5, 0, 0, 1446, 295, 1, 0, 0, 0, 1447, 1450, 3, 294, 145, 0, 1448, 1450, 5, 95, 0, 0, 1449, 1447, 1, 0, 0, 0, 1449, 1448, 1, 0, 0, 0, 1450, 297, 1, 0, 0, 0, 1451, 1452, 5, 48, 0, 0, 1452, 1453, 7, 6, 0, 0, 1453, 1457, 3, 294, 145, 0, 1454, 1456, 3, 296, 146, 0, 1455, 1454, 1, 0, 0, 0, 1456, 1459, 1, 0, 0, 0, 1457, 1455, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1460, 1, 0, 0, 0, 1459, 1457, 1, 0, 0, 0, 1460, 1461, 3, 294, 145, 0, 1461, 1466, 1, 0, 0, 0, 1462, 1463, 5, 48, 0, 0, 1463, 1464, 7, 6, 0, 0, 1464, 1466, 3, 294, 145, 0, 1465, 1451, 1, 0, 0, 0, 1465, 1462, 1, 0, 0, 0, 1466, 299, 1, 0, 0, 0, 1467, 1468, 7, 7, 0, 0, 1468, 301, 1, 0, 0, 0, 1469, 1472, 3, 300, 148, 0, 1470, 1472, 5, 95, 0, 0, 1471, 1469, 1, 0, 0, 0, 1471, 1470, 1, 0, 0, 0, 1472, 303, 1, 0, 0, 0, 1473, 1474, 5, 48, 0, 0, 1474, 1475, 7, 8, 0, 0, 1475, 1479, 3, 300, 148, 0, 1476, 1478, 3, 302, 149, 0, 1477, 1476, 1, 0, 0, 0, 1478, 1481, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1479, 1480, 1, 0, 0, 0, 1480, 1482, 1, 0, 0, 0, 1481, 1479, 1, 0, 0, 0, 1482, 1483, 3, 300, 148, 0, 1483, 1488, 1, 0, 0, 0, 1484, 1485, 5, 48, 0, 0, 1485, 1486, 7, 8, 0, 0, 1486, 1488, 3, 300, 148, 0, 1487, 1473, 1, 0, 0, 0, 1487, 1484, 1, 0, 0, 0, 1488, 305, 1, 0, 0, 0, 1489, 1493, 3, 292, 144, 0, 1490, 1493, 3, 298, 147, 0, 1491, 1493, 3, 304, 150, 0, 1492, 1489, 1, 0, 0, 0, 1492, 1490, 1, 0, 0, 0, 1492, 1491, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 1496, 7, 9, 0, 0, 1495, 1497, 7, 10, 0, 0, 1496, 1495, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 307, 1, 0, 0, 0, 1498, 1502, 3, 292, 144, 0, 1499, 1502, 3, 298, 147, 0, 1500, 1502, 3, 304, 150, 0, 1501, 1498, 1, 0, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1500, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 1504, 7, 10, 0, 0, 1504, 309, 1, 0, 0, 0, 1505, 1506, 5, 116, 0, 0, 1506, 1507, 5, 114, 0, 0, 1507, 1508, 5, 117, 0, 0, 1508, 1515, 5, 101, 0, 0, 1509, 1510, 5, 102, 0, 0, 1510, 1511, 5, 97, 0, 0, 1511, 1512, 5, 108, 0, 0, 1512, 1513, 5, 115, 0, 0, 1513, 1515, 5, 101, 0, 0, 1514, 1505, 1, 0, 0, 0, 1514, 1509, 1, 0, 0, 0, 1515, 311, 1, 0, 0, 0, 1516, 1517, 5, 110, 0, 0, 1517, 1518, 5, 117, 0, 0, 1518, 1519, 5, 108, 0, 0, 1519, 1520, 5, 108, 0, 0, 1520, 313, 1, 0, 0, 0, 1521, 1524, 5, 39, 0, 0, 1522, 1525, 3, 328, 162, 0, 1523, 1525, 8, 11, 0, 0, 1524, 1522, 1, 0, 0, 0, 1524, 1523, 1, 0, 0, 0, 1525, 1526, 1, 0, 0, 0, 1526, 1527, 5, 39, 0, 0, 1527, 315, 1, 0, 0, 0, 1528, 1529, 3, 346, 171, 0, 1529, 317, 1, 0, 0, 0, 1530, 1533, 3, 330, 163, 0, 1531, 1533, 5, 95, 0, 0, 1532, 1530, 1, 0, 0, 0, 1532, 1531, 1, 0, 0, 0, 1533, 1539, 1, 0, 0, 0, 1534, 1538, 3, 330, 163, 0, 1535, 1538, 5, 95, 0, 0, 1536, 1538, 3, 316, 156, 0, 1537, 1534, 1, 0, 0, 0, 1537, 1535, 1, 0, 0, 0, 1537, 1536, 1, 0, 0, 0, 1538, 1541, 1, 0, 0, 0, 1539, 1537, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1550, 1, 0, 0, 0, 1541, 1539, 1, 0, 0, 0, 1542, 1544, 5, 96, 0, 0, 1543, 1545, 8, 12, 0, 0, 1544, 1543, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1544, 1, 0, 0, 0, 1546, 1547, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 1550, 5, 96, 0, 0, 1549, 1532, 1, 0, 0, 0, 1549, 1542, 1, 0, 0, 0, 1550, 319, 1, 0, 0, 0, 1551, 1600, 3, 318, 157, 0, 1552, 1600, 3, 254, 125, 0, 1553, 1600, 3, 232, 114, 0, 1554, 1600, 3, 166, 81, 0, 1555, 1600, 3, 188, 92, 0, 1556, 1600, 3, 168, 82, 0, 1557, 1600, 3, 164, 80, 0, 1558, 1600, 3, 268, 132, 0, 1559, 1600, 3, 234, 115, 0, 1560, 1600, 3, 218, 107, 0, 1561, 1600, 3, 228, 112, 0, 1562, 1600, 3, 248, 122, 0, 1563, 1600, 3, 256, 126, 0, 1564, 1600, 3, 190, 93, 0, 1565, 1600, 3, 148, 72, 0, 1566, 1600, 3, 246, 121, 0, 1567, 1600, 3, 170, 83, 0, 1568, 1600, 3, 244, 120, 0, 1569, 1600, 3, 236, 116, 0, 1570, 1600, 3, 226, 111, 0, 1571, 1600, 3, 262, 129, 0, 1572, 1600, 3, 266, 131, 0, 1573, 1600, 3, 258, 127, 0, 1574, 1600, 3, 242, 119, 0, 1575, 1600, 3, 216, 106, 0, 1576, 1600, 3, 252, 124, 0, 1577, 1600, 3, 222, 109, 0, 1578, 1600, 3, 224, 110, 0, 1579, 1600, 3, 220, 108, 0, 1580, 1600, 3, 270, 133, 0, 1581, 1600, 3, 230, 113, 0, 1582, 1600, 3, 240, 118, 0, 1583, 1600, 3, 264, 130, 0, 1584, 1600, 3, 178, 87, 0, 1585, 1600, 3, 134, 65, 0, 1586, 1600, 3, 136, 66, 0, 1587, 1600, 3, 130, 63, 0, 1588, 1600, 3, 132, 64, 0, 1589, 1600, 3, 138, 67, 0, 1590, 1600, 3, 140, 68, 0, 1591, 1600, 3, 142, 69, 0, 1592, 1600, 3, 144, 70, 0, 1593, 1600, 3, 128, 62, 0, 1594, 1600, 3, 272, 134, 0, 1595, 1600, 3, 274, 135, 0, 1596, 1600, 3, 238, 117, 0, 1597, 1600, 3, 260, 128, 0, 1598, 1600, 3, 250, 123, 0, 1599, 1551, 1, 0, 0, 0, 1599, 1552, 1, 0, 0, 0, 1599, 1553, 1, 0, 0, 0, 1599, 1554, 1, 0, 0, 0, 1599, 1555, 1, 0, 0, 0, 1599, 1556, 1, 0, 0, 0, 1599, 1557, 1, 0, 0, 0, 1599, 1558, 1, 0, 0, 0, 1599, 1559, 1, 0, 0, 0, 1599, 1560, 1, 0, 0, 0, 1599, 1561, 1, 0, 0, 0, 1599, 1562, 1, 0, 0, 0, 1599, 1563, 1, 0, 0, 0, 1599, 1564, 1, 0, 0, 0, 1599, 1565, 1, 0, 0, 0, 1599, 1566, 1, 0, 0, 0, 1599, 1567, 1, 0, 0, 0, 1599, 1568, 1, 0, 0, 0, 1599, 1569, 1, 0, 0, 0, 1599, 1570, 1, 0, 0, 0, 1599, 1571, 1, 0, 0, 0, 1599, 1572, 1, 0, 0, 0, 1599, 1573, 1, 0, 0, 0, 1599, 1574, 1, 0, 0, 0, 1599, 1575, 1, 0, 0, 0, 1599, 1576, 1, 0, 0, 0, 1599, 1577, 1, 0, 0, 0, 1599, 1578, 1, 0, 0, 0, 1599, 1579, 1, 0, 0, 0, 1599, 1580, 1, 0, 0, 0, 1599, 1581, 1, 0, 0, 0, 1599, 1582, 1, 0, 0, 0, 1599, 1583, 1, 0, 0, 0, 1599, 1584, 1, 0, 0, 0, 1599, 1585, 1, 0, 0, 0, 1599, 1586, 1, 0, 0, 0, 1599, 1587, 1, 0, 0, 0, 1599, 1588, 1, 0, 0, 0, 1599, 1589, 1, 0, 0, 0, 1599, 1590, 1, 0, 0, 0, 1599, 1591, 1, 0, 0, 0, 1599, 1592, 1, 0, 0, 0, 1599, 1593, 1, 0, 0, 0, 1599, 1594, 1, 0, 0, 0, 1599, 1595, 1, 0, 0, 0, 1599, 1596, 1, 0, 0, 0, 1599, 1597, 1, 0, 0, 0, 1599, 1598, 1, 0, 0, 0, 1600, 321, 1, 0, 0, 0, 1601, 1602, 5, 36, 0, 0, 1602, 1603, 3, 320, 158, 0, 1603, 323, 1, 0, 0, 0, 1604, 1605, 5, 92, 0, 0, 1605, 1606, 5, 117, 0, 0, 1606, 1607, 3, 294, 145, 0, 1607, 1608, 3, 294, 145, 0, 1608, 1609, 3, 294, 145, 0, 1609, 1610, 3, 294, 145, 0, 1610, 325, 1, 0, 0, 0, 1611, 1612, 5, 92, 0, 0, 1612, 1613, 7, 13, 0, 0, 1613, 327, 1, 0, 0, 0, 1614, 1617, 3, 324, 160, 0, 1615, 1617, 3, 326, 161, 0, 1616, 1614, 1, 0, 0, 0, 1616, 1615, 1, 0, 0, 0, 1617, 329, 1, 0, 0, 0, 1618, 1624, 3, 344, 170, 0, 1619, 1624, 3, 336, 166, 0, 1620, 1624, 3, 342, 169, 0, 1621, 1624, 3, 338, 167, 0, 1622, 1624, 3, 340, 168, 0, 1623, 1618, 1, 0, 0, 0, 1623, 1619, 1, 0, 0, 0, 1623, 1620, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1623, 1622, 1, 0, 0, 0, 1624, 331, 1, 0, 0, 0, 1625, 1626, 5, 34, 0, 0, 1626, 1627, 1, 0, 0, 0, 1627, 1628, 6, 164, 4, 0, 1628, 333, 1, 0, 0, 0, 1629, 1630, 5, 34, 0, 0, 1630, 1631, 5, 34, 0, 0, 1631, 1632, 5, 34, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634, 6, 165, 5, 0, 1634, 335, 1, 0, 0, 0, 1635, 1636, 7, 14, 0, 0, 1636, 337, 1, 0, 0, 0, 1637, 1638, 7, 15, 0, 0, 1638, 339, 1, 0, 0, 0, 1639, 1640, 7, 16, 0, 0, 1640, 341, 1, 0, 0, 0, 1641, 1642, 7, 17, 0, 0, 1642, 343, 1, 0, 0, 0, 1643, 1644, 7, 18, 0, 0, 1644, 345, 1, 0, 0, 0, 1645, 1646, 7, 19, 0, 0, 1646, 347, 1, 0, 0, 0, 1647, 1648, 7, 20, 0, 0, 1648, 349, 1, 0, 0, 0, 1649, 1650, 5, 34, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1652, 6, 173, 3, 0, 1652, 351, 1, 0, 0, 0, 1653, 1654, 3, 322, 159, 0, 1654, 353, 1, 0, 0, 0, 1655, 1657, 8, 21, 0, 0, 1656, 1655, 1, 0, 0, 0, 1657, 1658, 1, 0, 0, 0, 1658, 1656, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1662, 1, 0, 0, 0, 1660, 1662, 5, 36, 0, 0, 1661, 1656, 1, 0, 0, 0, 1661, 1660, 1, 0, 0, 0, 1662, 355, 1, 0, 0, 0, 1663, 1666, 3, 326, 161, 0, 1664, 1666, 3, 324, 160, 0, 1665, 1663, 1, 0, 0, 0, 1665, 1664, 1, 0, 0, 0, 1666, 357, 1, 0, 0, 0, 1667, 1668, 5, 36, 0, 0, 1668, 1669, 5, 123, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 1671, 6, 177, 2, 0, 1671, 359, 1, 0, 0, 0, 1672, 1674, 3, 362, 179, 0, 1673, 1672, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1676, 5, 34, 0, 0, 1676, 1677, 5, 34, 0, 0, 1677, 1678, 5, 34, 0, 0, 1678, 1679, 1, 0, 0, 0, 1679, 1680, 6, 178, 3, 0, 1680, 361, 1, 0, 0, 0, 1681, 1683, 5, 34, 0, 0, 1682, 1681, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1685, 1, 0, 0, 0, 1685, 363, 1, 0, 0, 0, 1686, 1687, 3, 322, 159, 0, 1687, 365, 1, 0, 0, 0, 1688, 1690, 8, 22, 0, 0, 1689, 1688, 1, 0, 0, 0, 1690, 1691, 1, 0, 0, 0, 1691, 1689, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1695, 5, 36, 0, 0, 1694, 1689, 1, 0, 0, 0, 1694, 1693, 1, 0, 0, 0, 1695, 367, 1, 0, 0, 0, 1696, 1697, 5, 36, 0, 0, 1697, 1698, 5, 123, 0, 0, 1698, 1699, 1, 0, 0, 0, 1699, 1700, 6, 182, 2, 0, 1700, 369, 1, 0, 0, 0, 1701, 1702, 3, 24, 10, 0, 1702, 1703, 1, 0, 0, 0, 1703, 1704, 6, 183, 3, 0, 1704, 1705, 6, 183, 6, 0, 1705, 371, 1, 0, 0, 0, 1706, 1707, 3, 28, 12, 0, 1707, 1708, 1, 0, 0, 0, 1708, 1709, 6, 184, 3, 0, 1709, 1710, 6, 184, 7, 0, 1710, 373, 1, 0, 0, 0, 1711, 1712, 3, 22, 9, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1714, 6, 185, 1, 0, 1714, 1715, 6, 185, 8, 0, 1715, 375, 1, 0, 0, 0, 1716, 1717, 3, 26, 11, 0, 1717, 1718, 1, 0, 0, 0, 1718, 1719, 6, 186, 1, 0, 1719, 1720, 6, 186, 9, 0, 1720, 377, 1, 0, 0, 0, 1721, 1722, 3, 30, 13, 0, 1722, 1723, 1, 0, 0, 0, 1723, 1724, 6, 187, 2, 0, 1724, 1725, 6, 187, 10, 0, 1725, 379, 1, 0, 0, 0, 1726, 1727, 3, 32, 14, 0, 1727, 1728, 1, 0, 0, 0, 1728, 1729, 6, 188, 3, 0, 1729, 1730, 6, 188, 11, 0, 1730, 381, 1, 0, 0, 0, 1731, 1732, 3, 18, 7, 0, 1732, 1733, 1, 0, 0, 0, 1733, 1734, 6, 189, 12, 0, 1734, 383, 1, 0, 0, 0, 1735, 1736, 3, 20, 8, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1738, 6, 190, 13, 0, 1738, 385, 1, 0, 0, 0, 1739, 1740, 3, 34, 15, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1742, 6, 191, 14, 0, 1742, 387, 1, 0, 0, 0, 1743, 1744, 3, 36, 16, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1746, 6, 192, 15, 0, 1746, 389, 1, 0, 0, 0, 1747, 1748, 3, 38, 17, 0, 1748, 1749, 1, 0, 0, 0, 1749, 1750, 6, 193, 16, 0, 1750, 391, 1, 0, 0, 0, 1751, 1752, 3, 40, 18, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1754, 6, 194, 17, 0, 1754, 393, 1, 0, 0, 0, 1755, 1756, 3, 42, 19, 0, 1756, 1757, 1, 0, 0, 0, 1757, 1758, 6, 195, 18, 0, 1758, 395, 1, 0, 0, 0, 1759, 1760, 3, 44, 20, 0, 1760, 1761, 1, 0, 0, 0, 1761, 1762, 6, 196, 19, 0, 1762, 397, 1, 0, 0, 0, 1763, 1764, 3, 46, 21, 0, 1764, 1765, 1, 0, 0, 0, 1765, 1766, 6, 197, 20, 0, 1766, 399, 1, 0, 0, 0, 1767, 1768, 3, 48, 22, 0, 1768, 1769, 1, 0, 0, 0, 1769, 1770, 6, 198, 21, 0, 1770, 401, 1, 0, 0, 0, 1771, 1772, 3, 50, 23, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1774, 6, 199, 22, 0, 1774, 403, 1, 0, 0, 0, 1775, 1778, 5, 33, 0, 0, 1776, 1779, 3, 14, 5, 0, 1777, 1779, 3, 12, 4, 0, 1778, 1776, 1, 0, 0, 0, 1778, 1777, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, 1781, 6, 200, 23, 0, 1781, 405, 1, 0, 0, 0, 1782, 1783, 3, 54, 25, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1785, 6, 201, 24, 0, 1785, 407, 1, 0, 0, 0, 1786, 1787, 3, 56, 26, 0, 1787, 1788, 1, 0, 0, 0, 1788, 1789, 6, 202, 25, 0, 1789, 409, 1, 0, 0, 0, 1790, 1791, 3, 58, 27, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1793, 6, 203, 26, 0, 1793, 411, 1, 0, 0, 0, 1794, 1795, 3, 60, 28, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 6, 204, 27, 0, 1797, 413, 1, 0, 0, 0, 1798, 1799, 3, 62, 29, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1801, 6, 205, 28, 0, 1801, 415, 1, 0, 0, 0, 1802, 1803, 3, 64, 30, 0, 1803, 1804, 1, 0, 0, 0, 1804, 1805, 6, 206, 29, 0, 1805, 417, 1, 0, 0, 0, 1806, 1807, 3, 66, 31, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1809, 6, 207, 30, 0, 1809, 419, 1, 0, 0, 0, 1810, 1811, 3, 68, 32, 0, 1811, 1812, 1, 0, 0, 0, 1812, 1813, 6, 208, 31, 0, 1813, 421, 1, 0, 0, 0, 1814, 1815, 3, 70, 33, 0, 1815, 1816, 1, 0, 0, 0, 1816, 1817, 6, 209, 32, 0, 1817, 423, 1, 0, 0, 0, 1818, 1819, 3, 72, 34, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1821, 6, 210, 33, 0, 1821, 425, 1, 0, 0, 0, 1822, 1823, 3, 74, 35, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 6, 211, 34, 0, 1825, 427, 1, 0, 0, 0, 1826, 1827, 3, 76, 36, 0, 1827, 1828, 1, 0, 0, 0, 1828, 1829, 6, 212, 35, 0, 1829, 429, 1, 0, 0, 0, 1830, 1831, 3, 16, 6, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1833, 6, 213, 36, 0, 1833, 431, 1, 0, 0, 0, 1834, 1835, 3, 78, 37, 0, 1835, 1836, 1, 0, 0, 0, 1836, 1837, 6, 214, 37, 0, 1837, 433, 1, 0, 0, 0, 1838, 1839, 3, 80, 38, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1841, 6, 215, 38, 0, 1841, 435, 1, 0, 0, 0, 1842, 1843, 3, 82, 39, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 6, 216, 39, 0, 1845, 437, 1, 0, 0, 0, 1846, 1847, 3, 84, 40, 0, 1847, 1848, 1, 0, 0, 0, 1848, 1849, 6, 217, 40, 0, 1849, 439, 1, 0, 0, 0, 1850, 1851, 3, 86, 41, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1853, 6, 218, 41, 0, 1853, 441, 1, 0, 0, 0, 1854, 1855, 3, 88, 42, 0, 1855, 1856, 1, 0, 0, 0, 1856, 1857, 6, 219, 42, 0, 1857, 443, 1, 0, 0, 0, 1858, 1859, 3, 90, 43, 0, 1859, 1860, 1, 0, 0, 0, 1860, 1861, 6, 220, 43, 0, 1861, 445, 1, 0, 0, 0, 1862, 1865, 5, 63, 0, 0, 1863, 1866, 3, 14, 5, 0, 1864, 1866, 3, 12, 4, 0, 1865, 1863, 1, 0, 0, 0, 1865, 1864, 1, 0, 0, 0, 1866, 1867, 1, 0, 0, 0, 1867, 1868, 6, 221, 44, 0, 1868, 447, 1, 0, 0, 0, 1869, 1870, 3, 94, 45, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1872, 6, 222, 45, 0, 1872, 449, 1, 0, 0, 0, 1873, 1874, 3, 96, 46, 0, 1874, 1875, 1, 0, 0, 0, 1875, 1876, 6, 223, 46, 0, 1876, 451, 1, 0, 0, 0, 1877, 1878, 3, 98, 47, 0, 1878, 1879, 1, 0, 0, 0, 1879, 1880, 6, 224, 47, 0, 1880, 453, 1, 0, 0, 0, 1881, 1882, 3, 100, 48, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1884, 6, 225, 48, 0, 1884, 455, 1, 0, 0, 0, 1885, 1886, 3, 102, 49, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1888, 6, 226, 49, 0, 1888, 457, 1, 0, 0, 0, 1889, 1890, 3, 104, 50, 0, 1890, 1891, 1, 0, 0, 0, 1891, 1892, 6, 227, 50, 0, 1892, 459, 1, 0, 0, 0, 1893, 1894, 3, 106, 51, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1896, 6, 228, 51, 0, 1896, 461, 1, 0, 0, 0, 1897, 1898, 3, 208, 102, 0, 1898, 1899, 1, 0, 0, 0, 1899, 1900, 6, 229, 52, 0, 1900, 463, 1, 0, 0, 0, 1901, 1902, 3, 212, 104, 0, 1902, 1903, 1, 0, 0, 0, 1903, 1904, 6, 230, 53, 0, 1904, 465, 1, 0, 0, 0, 1905, 1906, 3, 214, 105, 0, 1906, 1907, 1, 0, 0, 0, 1907, 1908, 6, 231, 54, 0, 1908, 467, 1, 0, 0, 0, 1909, 1910, 3, 206, 101, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1912, 6, 232, 55, 0, 1912, 469, 1, 0, 0, 0, 1913, 1914, 3, 108, 52, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1916, 6, 233, 56, 0, 1916, 471, 1, 0, 0, 0, 1917, 1918, 3, 110, 53, 0, 1918, 1919, 1, 0, 0, 0, 1919, 1920, 6, 234, 57, 0, 1920, 473, 1, 0, 0, 0, 1921, 1922, 3, 112, 54, 0, 1922, 1923, 1, 0, 0, 0, 1923, 1924, 6, 235, 58, 0, 1924, 475, 1, 0, 0, 0, 1925, 1926, 3, 114, 55, 0, 1926, 1927, 1, 0, 0, 0, 1927, 1928, 6, 236, 59, 0, 1928, 477, 1, 0, 0, 0, 1929, 1930, 3, 116, 56, 0, 1930, 1931, 1, 0, 0, 0, 1931, 1932, 6, 237, 60, 0, 1932, 479, 1, 0, 0, 0, 1933, 1934, 3, 332, 164, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1936, 6, 238, 4, 0, 1936, 1937, 6, 238, 61, 0, 1937, 481, 1, 0, 0, 0, 1938, 1939, 3, 334, 165, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1941, 6, 239, 5, 0, 1941, 1942, 6, 239, 62, 0, 1942, 483, 1, 0, 0, 0, 1943, 1944, 3, 158, 77, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1946, 6, 240, 63, 0, 1946, 485, 1, 0, 0, 0, 1947, 1948, 3, 160, 78, 0, 1948, 1949, 1, 0, 0, 0, 1949, 1950, 6, 241, 64, 0, 1950, 487, 1, 0, 0, 0, 1951, 1952, 3, 154, 75, 0, 1952, 1953, 1, 0, 0, 0, 1953, 1954, 6, 242, 65, 0, 1954, 489, 1, 0, 0, 0, 1955, 1956, 3, 156, 76, 0, 1956, 1957, 1, 0, 0, 0, 1957, 1958, 6, 243, 66, 0, 1958, 491, 1, 0, 0, 0, 1959, 1960, 3, 174, 85, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1962, 6, 244, 67, 0, 1962, 493, 1, 0, 0, 0, 1963, 1964, 3, 210, 103, 0, 1964, 1965, 1, 0, 0, 0, 1965, 1966, 6, 245, 68, 0, 1966, 495, 1, 0, 0, 0, 1967, 1968, 3, 216, 106, 0, 1968, 1969, 1, 0, 0, 0, 1969, 1970, 6, 246, 69, 0, 1970, 497, 1, 0, 0, 0, 1971, 1972, 3, 130, 63, 0, 1972, 1973, 1, 0, 0, 0, 1973, 1974, 6, 247, 70, 0, 1974, 499, 1, 0, 0, 0, 1975, 1976, 3, 128, 62, 0, 1976, 1977, 1, 0, 0, 0, 1977, 1978, 6, 248, 71, 0, 1978, 501, 1, 0, 0, 0, 1979, 1980, 3, 132, 64, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1982, 6, 249, 72, 0, 1982, 503, 1, 0, 0, 0, 1983, 1984, 3, 134, 65, 0, 1984, 1985, 1, 0, 0, 0, 1985, 1986, 6, 250, 73, 0, 1986, 505, 1, 0, 0, 0, 1987, 1988, 3, 136, 66, 0, 1988, 1989, 1, 0, 0, 0, 1989, 1990, 6, 251, 74, 0, 1990, 507, 1, 0, 0, 0, 1991, 1992, 3, 138, 67, 0, 1992, 1993, 1, 0, 0, 0, 1993, 1994, 6, 252, 75, 0, 1994, 509, 1, 0, 0, 0, 1995, 1996, 3, 140, 68, 0, 1996, 1997, 1, 0, 0, 0, 1997, 1998, 6, 253, 76, 0, 1998, 511, 1, 0, 0, 0, 1999, 2000, 3, 142, 69, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2002, 6, 254, 77, 0, 2002, 513, 1, 0, 0, 0, 2003, 2004, 3, 144, 70, 0, 2004, 2005, 1, 0, 0, 0, 2005, 2006, 6, 255, 78, 0, 2006, 515, 1, 0, 0, 0, 2007, 2008, 3, 198, 97, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2010, 6, 256, 79, 0, 2010, 517, 1, 0, 0, 0, 2011, 2012, 3, 200, 98, 0, 2012, 2013, 1, 0, 0, 0, 2013, 2014, 6, 257, 80, 0, 2014, 519, 1, 0, 0, 0, 2015, 2016, 3, 202, 99, 0, 2016, 2017, 1, 0, 0, 0, 2017, 2018, 6, 258, 81, 0, 2018, 521, 1, 0, 0, 0, 2019, 2020, 3, 204, 100, 0, 2020, 2021, 1, 0, 0, 0, 2021, 2022, 6, 259, 82, 0, 2022, 523, 1, 0, 0, 0, 2023, 2024, 3, 118, 57, 0, 2024, 2025, 1, 0, 0, 0, 2025, 2026, 6, 260, 83, 0, 2026, 525, 1, 0, 0, 0, 2027, 2028, 3, 120, 58, 0, 2028, 2029, 1, 0, 0, 0, 2029, 2030, 6, 261, 84, 0, 2030, 527, 1, 0, 0, 0, 2031, 2032, 3, 122, 59, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2034, 6, 262, 85, 0, 2034, 529, 1, 0, 0, 0, 2035, 2036, 3, 180, 88, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2038, 6, 263, 86, 0, 2038, 531, 1, 0, 0, 0, 2039, 2040, 3, 182, 89, 0, 2040, 2041, 1, 0, 0, 0, 2041, 2042, 6, 264, 87, 0, 2042, 533, 1, 0, 0, 0, 2043, 2044, 3, 184, 90, 0, 2044, 2045, 1, 0, 0, 0, 2045, 2046, 6, 265, 88, 0, 2046, 535, 1, 0, 0, 0, 2047, 2048, 3, 186, 91, 0, 2048, 2049, 1, 0, 0, 0, 2049, 2050, 6, 266, 89, 0, 2050, 537, 1, 0, 0, 0, 2051, 2052, 3, 188, 92, 0, 2052, 2053, 1, 0, 0, 0, 2053, 2054, 6, 267, 90, 0, 2054, 539, 1, 0, 0, 0, 2055, 2056, 3, 190, 93, 0, 2056, 2057, 1, 0, 0, 0, 2057, 2058, 6, 268, 91, 0, 2058, 541, 1, 0, 0, 0, 2059, 2060, 3, 192, 94, 0, 2060, 2061, 1, 0, 0, 0, 2061, 2062, 6, 269, 92, 0, 2062, 543, 1, 0, 0, 0, 2063, 2064, 3, 194, 95, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2066, 6, 270, 93, 0, 2066, 545, 1, 0, 0, 0, 2067, 2068, 3, 196, 96, 0, 2068, 2069, 1, 0, 0, 0, 2069, 2070, 6, 271, 94, 0, 2070, 547, 1, 0, 0, 0, 2071, 2072, 3, 220, 108, 0, 2072, 2073, 1, 0, 0, 0, 2073, 2074, 6, 272, 95, 0, 2074, 549, 1, 0, 0, 0, 2075, 2076, 3, 222, 109, 0, 2076, 2077, 1, 0, 0, 0, 2077, 2078, 6, 273, 96, 0, 2078, 551, 1, 0, 0, 0, 2079, 2080, 3, 224, 110, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2082, 6, 274, 97, 0, 2082, 553, 1, 0, 0, 0, 2083, 2084, 3, 226, 111, 0, 2084, 2085, 1, 0, 0, 0, 2085, 2086, 6, 275, 98, 0, 2086, 555, 1, 0, 0, 0, 2087, 2088, 3, 228, 112, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2090, 6, 276, 99, 0, 2090, 557, 1, 0, 0, 0, 2091, 2092, 3, 230, 113, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2094, 6, 277, 100, 0, 2094, 559, 1, 0, 0, 0, 2095, 2096, 3, 232, 114, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2098, 6, 278, 101, 0, 2098, 561, 1, 0, 0, 0, 2099, 2100, 3, 234, 115, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2102, 6, 279, 102, 0, 2102, 563, 1, 0, 0, 0, 2103, 2104, 3, 236, 116, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 6, 280, 103, 0, 2106, 565, 1, 0, 0, 0, 2107, 2108, 3, 238, 117, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2110, 6, 281, 104, 0, 2110, 567, 1, 0, 0, 0, 2111, 2112, 3, 240, 118, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2114, 6, 282, 105, 0, 2114, 569, 1, 0, 0, 0, 2115, 2116, 3, 242, 119, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2118, 6, 283, 106, 0, 2118, 571, 1, 0, 0, 0, 2119, 2120, 3, 244, 120, 0, 2120, 2121, 1, 0, 0, 0, 2121, 2122, 6, 284, 107, 0, 2122, 573, 1, 0, 0, 0, 2123, 2124, 3, 246, 121, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2126, 6, 285, 108, 0, 2126, 575, 1, 0, 0, 0, 2127, 2128, 3, 248, 122, 0, 2128, 2129, 1, 0, 0, 0, 2129, 2130, 6, 286, 109, 0, 2130, 577, 1, 0, 0, 0, 2131, 2132, 3, 250, 123, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2134, 6, 287, 110, 0, 2134, 579, 1, 0, 0, 0, 2135, 2136, 3, 252, 124, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2138, 6, 288, 111, 0, 2138, 581, 1, 0, 0, 0, 2139, 2140, 3, 254, 125, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2142, 6, 289, 112, 0, 2142, 583, 1, 0, 0, 0, 2143, 2144, 3, 256, 126, 0, 2144, 2145, 1, 0, 0, 0, 2145, 2146, 6, 290, 113, 0, 2146, 585, 1, 0, 0, 0, 2147, 2148, 3, 258, 127, 0, 2148, 2149, 1, 0, 0, 0, 2149, 2150, 6, 291, 114, 0, 2150, 587, 1, 0, 0, 0, 2151, 2152, 3, 260, 128, 0, 2152, 2153, 1, 0, 0, 0, 2153, 2154, 6, 292, 115, 0, 2154, 589, 1, 0, 0, 0, 2155, 2156, 3, 262, 129, 0, 2156, 2157, 1, 0, 0, 0, 2157, 2158, 6, 293, 116, 0, 2158, 591, 1, 0, 0, 0, 2159, 2160, 3, 264, 130, 0, 2160, 2161, 1, 0, 0, 0, 2161, 2162, 6, 294, 117, 0, 2162, 593, 1, 0, 0, 0, 2163, 2164, 3, 266, 131, 0, 2164, 2165, 1, 0, 0, 0, 2165, 2166, 6, 295, 118, 0, 2166, 595, 1, 0, 0, 0, 2167, 2168, 3, 268, 132, 0, 2168, 2169, 1, 0, 0, 0, 2169, 2170, 6, 296, 119, 0, 2170, 597, 1, 0, 0, 0, 2171, 2172, 3, 270, 133, 0, 2172, 2173, 1, 0, 0, 0, 2173, 2174, 6, 297, 120, 0, 2174, 599, 1, 0, 0, 0, 2175, 2176, 3, 272, 134, 0, 2176, 2177, 1, 0, 0, 0, 2177, 2178, 6, 298, 121, 0, 2178, 601, 1, 0, 0, 0, 2179, 2180, 3, 274, 135, 0, 2180, 2181, 1, 0, 0, 0, 2181, 2182, 6, 299, 122, 0, 2182, 603, 1, 0, 0, 0, 2183, 2184, 3, 310, 153, 0, 2184, 2185, 1, 0, 0, 0, 2185, 2186, 6, 300, 123, 0, 2186, 605, 1, 0, 0, 0, 2187, 2188, 3, 292, 144, 0, 2188, 2189, 1, 0, 0, 0, 2189, 2190, 6, 301, 124, 0, 2190, 607, 1, 0, 0, 0, 2191, 2192, 3, 298, 147, 0, 2192, 2193, 1, 0, 0, 0, 2193, 2194, 6, 302, 125, 0, 2194, 609, 1, 0, 0, 0, 2195, 2196, 3, 304, 150, 0, 2196, 2197, 1, 0, 0, 0, 2197, 2198, 6, 303, 126, 0, 2198, 611, 1, 0, 0, 0, 2199, 2200, 3, 314, 155, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2202, 6, 304, 127, 0, 2202, 613, 1, 0, 0, 0, 2203, 2204, 3, 286, 141, 0, 2204, 2205, 1, 0, 0, 0, 2205, 2206, 6, 305, 128, 0, 2206, 615, 1, 0, 0, 0, 2207, 2208, 3, 312, 154, 0, 2208, 2209, 1, 0, 0, 0, 2209, 2210, 6, 306, 129, 0, 2210, 617, 1, 0, 0, 0, 2211, 2212, 3, 308, 152, 0, 2212, 2213, 1, 0, 0, 0, 2213, 2214, 6, 307, 130, 0, 2214, 619, 1, 0, 0, 0, 2215, 2216, 3, 306, 151, 0, 2216, 2217, 1, 0, 0, 0, 2217, 2218, 6, 308, 131, 0, 2218, 621, 1, 0, 0, 0, 2219, 2220, 3, 318, 157, 0, 2220, 2221, 1, 0, 0, 0, 2221, 2222, 6, 309, 132, 0, 2222, 623, 1, 0, 0, 0, 2223, 2226, 3, 8, 2, 0, 2224, 2226, 3, 6, 1, 0, 2225, 2223, 1, 0, 0, 0, 2225, 2224, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2228, 6, 310, 0, 0, 2228, 625, 1, 0, 0, 0, 2229, 2230, 3, 10, 3, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2232, 6, 311, 0, 0, 2232, 627, 1, 0, 0, 0, 2233, 2234, 3, 12, 4, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2236, 6, 312, 0, 0, 2236, 629, 1, 0, 0, 0, 2237, 2238, 9, 0, 0, 0, 2238, 631, 1, 0, 0, 0, 57, 0, 1, 2, 3, 638, 646, 648, 662, 674, 676, 681, 781, 785, 791, 796, 1145, 1153, 1388, 1394, 1400, 1404, 1410, 1418, 1421, 1426, 1431, 1437, 1443, 1449, 1457, 1465, 1471, 1479, 1487, 1492, 1496, 1501, 1514, 1524, 1532, 1537, 1539, 1546, 1549, 1599, 1616, 1623, 1658, 1661, 1665, 1673, 1684, 1691, 1694, 1778, 1865, 2225, 133, 0, 1, 0, 5, 3, 0, 5, 0, 0, 4, 0, 0, 5, 1, 0, 5, 2, 0, 7, 10, 0, 7, 12, 0, 7, 9, 0, 7, 11, 0, 7, 13, 0, 7, 14, 0, 7, 7, 0, 7, 8, 0, 7, 15, 0, 7, 16, 0, 7, 17, 0, 7, 18, 0, 7, 19, 0, 7, 20, 0, 7, 21, 0, 7, 22, 0, 7, 23, 0, 7, 24, 0, 7, 25, 0, 7, 26, 0, 7, 27, 0, 7, 28, 0, 7, 29, 0, 7, 30, 0, 7, 31, 0, 7, 32, 0, 7, 33, 0, 7, 34, 0, 7, 35, 0, 7, 36, 0, 7, 6, 0, 7, 37, 0, 7, 38, 0, 7, 39, 0, 7, 40, 0, 7, 41, 0, 7, 42, 0, 7, 43, 0, 7, 44, 0, 7, 45, 0, 7, 46, 0, 7, 47, 0, 7, 48, 0, 7, 49, 0, 7, 50, 0, 7, 51, 0, 7, 102, 0, 7, 104, 0, 7, 105, 0, 7, 101, 0, 7, 52, 0, 7, 53, 0, 7, 54, 0, 7, 55, 0, 7, 56, 0, 7, 150, 0, 7, 151, 0, 7, 77, 0, 7, 78, 0, 7, 75, 0, 7, 76, 0, 7, 85, 0, 7, 103, 0, 7, 106, 0, 7, 63, 0, 7, 62, 0, 7, 64, 0, 7, 65, 0, 7, 66, 0, 7, 67, 0, 7, 68, 0, 7, 69, 0, 7, 70, 0, 7, 97, 0, 7, 98, 0, 7, 99, 0, 7, 100, 0, 7, 57, 0, 7, 58, 0, 7, 59, 0, 7, 88, 0, 7, 89, 0, 7, 90, 0, 7, 91, 0, 7, 92, 0, 7, 93, 0, 7, 94, 0, 7, 95, 0, 7, 96, 0, 7, 108, 0, 7, 109, 0, 7, 110, 0, 7, 111, 0, 7, 112, 0, 7, 113, 0, 7, 114, 0, 7, 115, 0, 7, 116, 0, 7, 117, 0, 7, 118, 0, 7, 119, 0, 7, 120, 0, 7, 121, 0, 7, 122, 0, 7, 123, 0, 7, 124, 0, 7, 125, 0, 7, 126, 0, 7, 127, 0, 7, 128, 0, 7, 129, 0, 7, 130, 0, 7, 131, 0, 7, 132, 0, 7, 133, 0, 7, 134, 0, 7, 135, 0, 7, 144, 0, 7, 139, 0, 7, 140, 0, 7, 141, 0, 7, 146, 0, 7, 136, 0, 7, 145, 0, 7, 143, 0, 7, 142, 0, 7, 147, 0] \ No newline at end of file diff --git a/lib/archer/kotlin_parser/KotlinLexer.tokens b/lib/archer/kotlin_parser/KotlinLexer.tokens new file mode 100644 index 0000000..8692c66 --- /dev/null +++ b/lib/archer/kotlin_parser/KotlinLexer.tokens @@ -0,0 +1,292 @@ +ShebangLine=1 +DelimitedComment=2 +LineComment=3 +WS=4 +NL=5 +RESERVED=6 +DOT=7 +COMMA=8 +LPAREN=9 +RPAREN=10 +LSQUARE=11 +RSQUARE=12 +LCURL=13 +RCURL=14 +MULT=15 +MOD=16 +DIV=17 +ADD=18 +SUB=19 +INCR=20 +DECR=21 +CONJ=22 +DISJ=23 +EXCL_WS=24 +EXCL_NO_WS=25 +COLON=26 +SEMICOLON=27 +ASSIGNMENT=28 +ADD_ASSIGNMENT=29 +SUB_ASSIGNMENT=30 +MULT_ASSIGNMENT=31 +DIV_ASSIGNMENT=32 +MOD_ASSIGNMENT=33 +ARROW=34 +DOUBLE_ARROW=35 +RANGE=36 +COLONCOLON=37 +DOUBLE_SEMICOLON=38 +HASH=39 +AT_NO_WS=40 +AT_POST_WS=41 +AT_PRE_WS=42 +AT_BOTH_WS=43 +QUEST_WS=44 +QUEST_NO_WS=45 +LANGLE=46 +RANGLE=47 +LE=48 +GE=49 +EXCL_EQ=50 +EXCL_EQEQ=51 +AS_SAFE=52 +EQEQ=53 +EQEQEQ=54 +SINGLE_QUOTE=55 +AMP=56 +RETURN_AT=57 +CONTINUE_AT=58 +BREAK_AT=59 +THIS_AT=60 +SUPER_AT=61 +FILE=62 +FIELD=63 +PROPERTY=64 +GET=65 +SET=66 +RECEIVER=67 +PARAM=68 +SETPARAM=69 +DELEGATE=70 +PACKAGE=71 +IMPORT=72 +CLASS=73 +INTERFACE=74 +FUN=75 +OBJECT=76 +VAL=77 +VAR=78 +TYPE_ALIAS=79 +CONSTRUCTOR=80 +BY=81 +COMPANION=82 +INIT=83 +THIS=84 +SUPER=85 +TYPEOF=86 +WHERE=87 +IF=88 +ELSE=89 +WHEN=90 +TRY=91 +CATCH=92 +FINALLY=93 +FOR=94 +DO=95 +WHILE=96 +THROW=97 +RETURN=98 +CONTINUE=99 +BREAK=100 +AS=101 +IS=102 +IN=103 +NOT_IS=104 +NOT_IN=105 +OUT=106 +DYNAMIC=107 +PUBLIC=108 +PRIVATE=109 +PROTECTED=110 +INTERNAL=111 +ENUM=112 +SEALED=113 +ANNOTATION=114 +DATA=115 +INNER=116 +VALUE=117 +TAILREC=118 +OPERATOR=119 +INLINE=120 +INFIX=121 +EXTERNAL=122 +SUSPEND=123 +OVERRIDE=124 +ABSTRACT=125 +FINAL=126 +OPEN=127 +CONST=128 +LATEINIT=129 +VARARG=130 +NOINLINE=131 +CROSSINLINE=132 +REIFIED=133 +EXPECT=134 +ACTUAL=135 +RealLiteral=136 +FloatLiteral=137 +DoubleLiteral=138 +IntegerLiteral=139 +HexLiteral=140 +BinLiteral=141 +UnsignedLiteral=142 +LongLiteral=143 +BooleanLiteral=144 +NullLiteral=145 +CharacterLiteral=146 +Identifier=147 +IdentifierOrSoftKey=148 +FieldIdentifier=149 +QUOTE_OPEN=150 +TRIPLE_QUOTE_OPEN=151 +UNICODE_CLASS_LL=152 +UNICODE_CLASS_LM=153 +UNICODE_CLASS_LO=154 +UNICODE_CLASS_LT=155 +UNICODE_CLASS_LU=156 +UNICODE_CLASS_ND=157 +UNICODE_CLASS_NL=158 +QUOTE_CLOSE=159 +LineStrRef=160 +LineStrText=161 +LineStrEscapedChar=162 +LineStrExprStart=163 +TRIPLE_QUOTE_CLOSE=164 +MultiLineStringQuote=165 +MultiLineStrRef=166 +MultiLineStrText=167 +MultiLineStrExprStart=168 +Inside_Comment=169 +Inside_WS=170 +Inside_NL=171 +ErrorCharacter=172 +'...'=6 +'.'=7 +','=8 +'('=9 +')'=10 +'['=11 +']'=12 +'{'=13 +'}'=14 +'*'=15 +'%'=16 +'/'=17 +'+'=18 +'-'=19 +'++'=20 +'--'=21 +'&&'=22 +'||'=23 +'!'=25 +':'=26 +';'=27 +'='=28 +'+='=29 +'-='=30 +'*='=31 +'/='=32 +'%='=33 +'->'=34 +'=>'=35 +'..'=36 +'::'=37 +';;'=38 +'#'=39 +'@'=40 +'?'=45 +'<'=46 +'>'=47 +'<='=48 +'>='=49 +'!='=50 +'!=='=51 +'as?'=52 +'=='=53 +'==='=54 +'\''=55 +'&'=56 +'file'=62 +'field'=63 +'property'=64 +'get'=65 +'set'=66 +'receiver'=67 +'param'=68 +'setparam'=69 +'delegate'=70 +'package'=71 +'import'=72 +'class'=73 +'interface'=74 +'fun'=75 +'object'=76 +'val'=77 +'var'=78 +'typealias'=79 +'constructor'=80 +'by'=81 +'companion'=82 +'init'=83 +'this'=84 +'super'=85 +'typeof'=86 +'where'=87 +'if'=88 +'else'=89 +'when'=90 +'try'=91 +'catch'=92 +'finally'=93 +'for'=94 +'do'=95 +'while'=96 +'throw'=97 +'return'=98 +'continue'=99 +'break'=100 +'as'=101 +'is'=102 +'in'=103 +'out'=106 +'dynamic'=107 +'public'=108 +'private'=109 +'protected'=110 +'internal'=111 +'enum'=112 +'sealed'=113 +'annotation'=114 +'data'=115 +'inner'=116 +'value'=117 +'tailrec'=118 +'operator'=119 +'inline'=120 +'infix'=121 +'external'=122 +'suspend'=123 +'override'=124 +'abstract'=125 +'final'=126 +'open'=127 +'const'=128 +'lateinit'=129 +'vararg'=130 +'noinline'=131 +'crossinline'=132 +'reified'=133 +'expect'=134 +'actual'=135 +'null'=145 +'"""'=151 diff --git a/lib/archer/kotlin_parser/KotlinParser.g4 b/lib/archer/kotlin_parser/KotlinParser.g4 new file mode 100644 index 0000000..53356a1 --- /dev/null +++ b/lib/archer/kotlin_parser/KotlinParser.g4 @@ -0,0 +1,926 @@ +/** + * Kotlin syntax grammar in ANTLR4 notation + */ + +parser grammar KotlinParser; + +options { tokenVocab = KotlinLexer; } + +// SECTION: general + +kotlinFile + : shebangLine? NL* fileAnnotation* packageHeader importList topLevelObject* EOF + ; + +script + : shebangLine? NL* fileAnnotation* packageHeader importList (statement semi)* EOF + ; + +shebangLine + : ShebangLine NL+ + ; + +fileAnnotation + : (AT_NO_WS | AT_PRE_WS) FILE NL* COLON NL* (LSQUARE unescapedAnnotation+ RSQUARE | unescapedAnnotation) NL* + ; + +packageHeader + : (PACKAGE identifier semi?)? + ; + +importList + : importHeader* + ; + +importHeader + : IMPORT identifier (DOT MULT | importAlias)? semi? + ; + +importAlias + : AS simpleIdentifier + ; + +topLevelObject + : declaration semis? + ; + +typeAlias + : modifiers? TYPE_ALIAS NL* simpleIdentifier (NL* typeParameters)? NL* ASSIGNMENT NL* type + ; + +declaration + : classDeclaration + | objectDeclaration + | functionDeclaration + | propertyDeclaration + | typeAlias + ; + +// SECTION: classes + +classDeclaration + : modifiers? (CLASS | (FUN NL*)? INTERFACE) NL* simpleIdentifier + (NL* typeParameters)? (NL* primaryConstructor)? + (NL* COLON NL* delegationSpecifiers)? + (NL* typeConstraints)? + (NL* classBody | NL* enumClassBody)? + ; + +primaryConstructor + : (modifiers? CONSTRUCTOR NL*)? classParameters + ; + +classBody + : LCURL NL* classMemberDeclarations NL* RCURL + ; + +classParameters + : LPAREN NL* (classParameter (NL* COMMA NL* classParameter)* (NL* COMMA)?)? NL* RPAREN + ; + +classParameter + : modifiers? (VAL | VAR)? NL* simpleIdentifier COLON NL* type (NL* ASSIGNMENT NL* expression)? + ; + +delegationSpecifiers + : annotatedDelegationSpecifier (NL* COMMA NL* annotatedDelegationSpecifier)* + ; + +delegationSpecifier + : constructorInvocation + | explicitDelegation + | userType + | functionType + | SUSPEND NL* functionType + ; + +constructorInvocation + : userType valueArguments + ; + +annotatedDelegationSpecifier + : annotation* NL* delegationSpecifier + ; + +explicitDelegation + : (userType | functionType) NL* BY NL* expression + ; + +typeParameters + : LANGLE NL* typeParameter (NL* COMMA NL* typeParameter)* (NL* COMMA)? NL* RANGLE + ; + +typeParameter + : typeParameterModifiers? NL* simpleIdentifier (NL* COLON NL* type)? + ; + +typeConstraints + : WHERE NL* typeConstraint (NL* COMMA NL* typeConstraint)* + ; + +typeConstraint + : annotation* simpleIdentifier NL* COLON NL* type + ; + +// SECTION: classMembers + +classMemberDeclarations + : (classMemberDeclaration semis?)* + ; + +classMemberDeclaration + : declaration + | companionObject + | anonymousInitializer + | secondaryConstructor + ; + +anonymousInitializer + : INIT NL* block + ; + +companionObject + : modifiers? COMPANION NL* OBJECT + (NL* simpleIdentifier)? + (NL* COLON NL* delegationSpecifiers)? + (NL* classBody)? + ; + +functionValueParameters + : LPAREN NL* (functionValueParameter (NL* COMMA NL* functionValueParameter)* (NL* COMMA)?)? NL* RPAREN + ; + +functionValueParameter + : parameterModifiers? parameter (NL* ASSIGNMENT NL* expression)? + ; + +functionDeclaration + : modifiers? + FUN (NL* typeParameters)? (NL* receiverType NL* DOT)? NL* simpleIdentifier + NL* functionValueParameters + (NL* COLON NL* type)? + (NL* typeConstraints)? + (NL* functionBody)? + ; + +functionBody + : block + | ASSIGNMENT NL* expression + ; + +variableDeclaration + : annotation* NL* simpleIdentifier (NL* COLON NL* type)? + ; + +multiVariableDeclaration + : LPAREN NL* variableDeclaration (NL* COMMA NL* variableDeclaration)* (NL* COMMA)? NL* RPAREN + ; + +propertyDeclaration + : modifiers? (VAL | VAR) + (NL* typeParameters)? + (NL* receiverType NL* DOT)? + (NL* (multiVariableDeclaration | variableDeclaration)) + (NL* typeConstraints)? + (NL* (ASSIGNMENT NL* expression | propertyDelegate))? + (NL+ SEMICOLON)? NL* (getter? (NL* semi? setter)? | setter? (NL* semi? getter)?) + ; + +propertyDelegate + : BY NL* expression + ; + +getter + : modifiers? GET + (NL* LPAREN NL* RPAREN (NL* COLON NL* type)? NL* functionBody)? + ; + +setter + : modifiers? SET + (NL* LPAREN NL* functionValueParameterWithOptionalType (NL* COMMA)? NL* RPAREN (NL* COLON NL* type)? NL* functionBody)? + ; + +parametersWithOptionalType + : LPAREN NL* (functionValueParameterWithOptionalType (NL* COMMA NL* functionValueParameterWithOptionalType)* (NL* COMMA)?)? NL* RPAREN + ; + +functionValueParameterWithOptionalType + : parameterModifiers? parameterWithOptionalType (NL* ASSIGNMENT NL* expression)? + ; + +parameterWithOptionalType + : simpleIdentifier NL* (COLON NL* type)? + ; + +parameter + : simpleIdentifier NL* COLON NL* type + ; + +objectDeclaration + : modifiers? OBJECT + NL* simpleIdentifier + (NL* COLON NL* delegationSpecifiers)? + (NL* classBody)? + ; + +secondaryConstructor + : modifiers? CONSTRUCTOR NL* functionValueParameters (NL* COLON NL* constructorDelegationCall)? NL* block? + ; + +constructorDelegationCall + : (THIS | SUPER) NL* valueArguments + ; + +// SECTION: enumClasses + +enumClassBody + : LCURL NL* enumEntries? (NL* SEMICOLON NL* classMemberDeclarations)? NL* RCURL + ; + +enumEntries + : enumEntry (NL* COMMA NL* enumEntry)* NL* COMMA? + ; + +enumEntry + : (modifiers NL*)? simpleIdentifier (NL* valueArguments)? (NL* classBody)? + ; + +// SECTION: types + +type + : typeModifiers? (functionType | parenthesizedType | nullableType | typeReference | definitelyNonNullableType) + ; + +typeReference + : userType + | DYNAMIC + ; + +nullableType + : (typeReference | parenthesizedType) NL* quest+ + ; + +quest + : QUEST_NO_WS + | QUEST_WS + ; + +userType + : simpleUserType (NL* DOT NL* simpleUserType)* + ; + +simpleUserType + : simpleIdentifier (NL* typeArguments)? + ; + +typeProjection + : typeProjectionModifiers? type + | MULT + ; + +typeProjectionModifiers + : typeProjectionModifier+ + ; + +typeProjectionModifier + : varianceModifier NL* + | annotation + ; + +functionType + : (receiverType NL* DOT NL*)? functionTypeParameters NL* ARROW NL* type + ; + +functionTypeParameters + : LPAREN NL* (parameter | type)? (NL* COMMA NL* (parameter | type))* (NL* COMMA)? NL* RPAREN + ; + +parenthesizedType + : LPAREN NL* type NL* RPAREN + ; + +receiverType + : typeModifiers? (parenthesizedType | nullableType | typeReference) + ; + +parenthesizedUserType + : LPAREN NL* (userType | parenthesizedUserType) NL* RPAREN + ; + +definitelyNonNullableType + : typeModifiers? (userType | parenthesizedUserType) NL* AMP NL* typeModifiers? (userType | parenthesizedUserType) + ; + +// SECTION: statements + +statements + : (statement (semis statement)*)? semis? + ; + +statement + : (label | annotation)* ( declaration | assignment | loopStatement | expression) + ; + +label + : simpleIdentifier (AT_NO_WS | AT_POST_WS) NL* + ; + +controlStructureBody + : block + | statement + ; + +block + : LCURL NL* statements NL* RCURL + ; + +loopStatement + : forStatement + | whileStatement + | doWhileStatement + ; + +forStatement + : FOR NL* LPAREN annotation* (variableDeclaration | multiVariableDeclaration) + IN expression RPAREN NL* controlStructureBody? + ; + +whileStatement + : WHILE NL* LPAREN expression RPAREN NL* (controlStructureBody | SEMICOLON) + ; + +doWhileStatement + : DO NL* controlStructureBody? NL* WHILE NL* LPAREN expression RPAREN + ; + +assignment + : (directlyAssignableExpression ASSIGNMENT | assignableExpression assignmentAndOperator) NL* expression + ; + +semi + : (SEMICOLON | NL) NL* + ; + +semis + : (SEMICOLON | NL)+ + ; + +// SECTION: expressions + +expression + : disjunction + ; + +disjunction + : conjunction (NL* DISJ NL* conjunction)* + ; + +conjunction + : equality (NL* CONJ NL* equality)* + ; + +equality + : comparison (equalityOperator NL* comparison)* + ; + +comparison + : genericCallLikeComparison (comparisonOperator NL* genericCallLikeComparison)* + ; + +genericCallLikeComparison + : infixOperation callSuffix* + ; + +infixOperation + : elvisExpression (inOperator NL* elvisExpression | isOperator NL* type)* + ; + +elvisExpression + : infixFunctionCall (NL* elvis NL* infixFunctionCall)* + ; + +elvis + : QUEST_NO_WS COLON + ; + +infixFunctionCall + : rangeExpression (simpleIdentifier NL* rangeExpression)* + ; + +rangeExpression + : additiveExpression (RANGE NL* additiveExpression)* + ; + +additiveExpression + : multiplicativeExpression (additiveOperator NL* multiplicativeExpression)* + ; + +multiplicativeExpression + : asExpression (multiplicativeOperator NL* asExpression)* + ; + +asExpression + : prefixUnaryExpression (NL* asOperator NL* type)* + ; + +prefixUnaryExpression + : unaryPrefix* postfixUnaryExpression + ; + +unaryPrefix + : annotation + | label + | prefixUnaryOperator NL* + ; + +postfixUnaryExpression + : primaryExpression postfixUnarySuffix* + ; + +postfixUnarySuffix + : postfixUnaryOperator + | typeArguments + | callSuffix + | indexingSuffix + | navigationSuffix + ; + +directlyAssignableExpression + : postfixUnaryExpression assignableSuffix + | simpleIdentifier + | parenthesizedDirectlyAssignableExpression + ; + +parenthesizedDirectlyAssignableExpression + : LPAREN NL* directlyAssignableExpression NL* RPAREN + ; + +assignableExpression + : prefixUnaryExpression + | parenthesizedAssignableExpression + ; + +parenthesizedAssignableExpression + : LPAREN NL* assignableExpression NL* RPAREN + ; + +assignableSuffix + : typeArguments + | indexingSuffix + | navigationSuffix + ; + +indexingSuffix + : LSQUARE NL* expression (NL* COMMA NL* expression)* (NL* COMMA)? NL* RSQUARE + ; + +navigationSuffix + : memberAccessOperator NL* (simpleIdentifier | parenthesizedExpression | CLASS) + ; + +callSuffix + : typeArguments? (valueArguments? annotatedLambda | valueArguments) + ; + +annotatedLambda + : annotation* label? NL* lambdaLiteral + ; + +typeArguments + : LANGLE NL* typeProjection (NL* COMMA NL* typeProjection)* (NL* COMMA)? NL* RANGLE + ; + +valueArguments + : LPAREN NL* (valueArgument (NL* COMMA NL* valueArgument)* (NL* COMMA)? NL*)? RPAREN + ; + +valueArgument + : annotation? NL* (simpleIdentifier NL* ASSIGNMENT NL*)? MULT? NL* expression + ; + +primaryExpression + : parenthesizedExpression + | simpleIdentifier + | literalConstant + | stringLiteral + | callableReference + | functionLiteral + | objectLiteral + | collectionLiteral + | thisExpression + | superExpression + | ifExpression + | whenExpression + | tryExpression + | jumpExpression + ; + +parenthesizedExpression + : LPAREN NL* expression NL* RPAREN + ; + +collectionLiteral + : LSQUARE NL* (expression (NL* COMMA NL* expression)* (NL* COMMA)? NL*)? RSQUARE + ; + +literalConstant + : BooleanLiteral + | IntegerLiteral + | HexLiteral + | BinLiteral + | CharacterLiteral + | RealLiteral + | NullLiteral + | LongLiteral + | UnsignedLiteral + ; + +stringLiteral + : lineStringLiteral + | multiLineStringLiteral + ; + +lineStringLiteral + : QUOTE_OPEN (lineStringContent | lineStringExpression)* QUOTE_CLOSE + ; + +multiLineStringLiteral + : TRIPLE_QUOTE_OPEN (multiLineStringContent | multiLineStringExpression | MultiLineStringQuote)* TRIPLE_QUOTE_CLOSE + ; + +lineStringContent + : LineStrText + | LineStrEscapedChar + | LineStrRef + ; + +lineStringExpression + : LineStrExprStart NL* expression NL* RCURL + ; + +multiLineStringContent + : MultiLineStrText + | MultiLineStringQuote + | MultiLineStrRef + ; + +multiLineStringExpression + : MultiLineStrExprStart NL* expression NL* RCURL + ; + +lambdaLiteral + : LCURL NL* (lambdaParameters? NL* ARROW NL*)? statements NL* RCURL + ; + +lambdaParameters + : lambdaParameter (NL* COMMA NL* lambdaParameter)* (NL* COMMA)? + ; + +lambdaParameter + : variableDeclaration + | multiVariableDeclaration (NL* COLON NL* type)? + ; + +anonymousFunction + : FUN + (NL* type NL* DOT)? + NL* parametersWithOptionalType + (NL* COLON NL* type)? + (NL* typeConstraints)? + (NL* functionBody)? + ; + +functionLiteral + : lambdaLiteral + | anonymousFunction + ; + +objectLiteral + : OBJECT (NL* COLON NL* delegationSpecifiers NL*)? (NL* classBody)? + ; + +thisExpression + : THIS + | THIS_AT + ; + +superExpression + : SUPER (LANGLE NL* type NL* RANGLE)? (AT_NO_WS simpleIdentifier)? + | SUPER_AT + ; + +ifExpression + : IF NL* LPAREN NL* expression NL* RPAREN NL* + ( controlStructureBody + | controlStructureBody? NL* SEMICOLON? NL* ELSE NL* (controlStructureBody | SEMICOLON) + | SEMICOLON) + ; + +whenSubject + : LPAREN (annotation* NL* VAL NL* variableDeclaration NL* ASSIGNMENT NL*)? expression RPAREN + ; + +whenExpression + : WHEN NL* whenSubject? NL* LCURL NL* (whenEntry NL*)* NL* RCURL + ; + +whenEntry + : whenCondition (NL* COMMA NL* whenCondition)* (NL* COMMA)? NL* ARROW NL* controlStructureBody semi? + | ELSE NL* ARROW NL* controlStructureBody semi? + ; + +whenCondition + : expression + | rangeTest + | typeTest + ; + +rangeTest + : inOperator NL* expression + ; + +typeTest + : isOperator NL* type + ; + +tryExpression + : TRY NL* block ((NL* catchBlock)+ (NL* finallyBlock)? | NL* finallyBlock) + ; + +catchBlock + : CATCH NL* LPAREN annotation* simpleIdentifier COLON type (NL* COMMA)? RPAREN NL* block + ; + +finallyBlock + : FINALLY NL* block + ; + +jumpExpression + : THROW NL* expression + | (RETURN | RETURN_AT) expression? + | CONTINUE + | CONTINUE_AT + | BREAK + | BREAK_AT + ; + +callableReference + : receiverType? COLONCOLON NL* (simpleIdentifier | CLASS) + ; + +assignmentAndOperator + : ADD_ASSIGNMENT + | SUB_ASSIGNMENT + | MULT_ASSIGNMENT + | DIV_ASSIGNMENT + | MOD_ASSIGNMENT + ; + +equalityOperator + : EXCL_EQ + | EXCL_EQEQ + | EQEQ + | EQEQEQ + ; + +comparisonOperator + : LANGLE + | RANGLE + | LE + | GE + ; + +inOperator + : IN + | NOT_IN + ; + +isOperator + : IS + | NOT_IS + ; + +additiveOperator + : ADD + | SUB + ; + +multiplicativeOperator + : MULT + | DIV + | MOD + ; + +asOperator + : AS + | AS_SAFE + ; + +prefixUnaryOperator + : INCR + | DECR + | SUB + | ADD + | excl + ; + +postfixUnaryOperator + : INCR + | DECR + | EXCL_NO_WS excl + ; + +excl + : EXCL_NO_WS + | EXCL_WS + ; + +memberAccessOperator + : NL* DOT + | NL* safeNav + | COLONCOLON + ; + +safeNav + : QUEST_NO_WS DOT + ; + +// SECTION: modifiers + +modifiers + : (annotation | modifier)+ + ; + +parameterModifiers + : (annotation | parameterModifier)+ + ; + +modifier + : (classModifier + | memberModifier + | visibilityModifier + | functionModifier + | propertyModifier + | inheritanceModifier + | parameterModifier + | platformModifier) NL* + ; + +typeModifiers + : typeModifier+ + ; + +typeModifier + : annotation + | SUSPEND NL* + ; + +classModifier + : ENUM + | SEALED + | ANNOTATION + | DATA + | INNER + | VALUE + ; + +memberModifier + : OVERRIDE + | LATEINIT + ; + +visibilityModifier + : PUBLIC + | PRIVATE + | INTERNAL + | PROTECTED + ; + +varianceModifier + : IN + | OUT + ; + +typeParameterModifiers + : typeParameterModifier+ + ; + +typeParameterModifier + : reificationModifier NL* + | varianceModifier NL* + | annotation + ; + +functionModifier + : TAILREC + | OPERATOR + | INFIX + | INLINE + | EXTERNAL + | SUSPEND + ; + +propertyModifier + : CONST + ; + +inheritanceModifier + : ABSTRACT + | FINAL + | OPEN + ; + +parameterModifier + : VARARG + | NOINLINE + | CROSSINLINE + ; + +reificationModifier + : REIFIED + ; + +platformModifier + : EXPECT + | ACTUAL + ; + +// SECTION: annotations + +annotation + : (singleAnnotation | multiAnnotation) NL* + ; + +singleAnnotation + : (annotationUseSiteTarget NL* | AT_NO_WS | AT_PRE_WS) unescapedAnnotation + ; + +multiAnnotation + : (annotationUseSiteTarget NL* | AT_NO_WS | AT_PRE_WS) LSQUARE unescapedAnnotation+ RSQUARE + ; + +annotationUseSiteTarget + : (AT_NO_WS | AT_PRE_WS) (FIELD | PROPERTY | GET | SET | RECEIVER | PARAM | SETPARAM | DELEGATE) NL* COLON + ; + +unescapedAnnotation + : constructorInvocation + | userType + ; + +// SECTION: identifiers + +simpleIdentifier + : Identifier + | ABSTRACT + | ANNOTATION + | BY + | CATCH + | COMPANION + | CONSTRUCTOR + | CROSSINLINE + | DATA + | DYNAMIC + | ENUM + | EXTERNAL + | FINAL + | FINALLY + | GET + | IMPORT + | INFIX + | INIT + | INLINE + | INNER + | INTERNAL + | LATEINIT + | NOINLINE + | OPEN + | OPERATOR + | OUT + | OVERRIDE + | PRIVATE + | PROTECTED + | PUBLIC + | REIFIED + | SEALED + | TAILREC + | SET + | VARARG + | WHERE + | FIELD + | PROPERTY + | RECEIVER + | PARAM + | SETPARAM + | DELEGATE + | FILE + | EXPECT + | ACTUAL + | CONST + | SUSPEND + | VALUE + ; + +identifier + : simpleIdentifier (NL* DOT simpleIdentifier)* + ; diff --git a/lib/archer/kotlin_parser/KotlinParser.interp b/lib/archer/kotlin_parser/KotlinParser.interp new file mode 100644 index 0000000..32c94cf --- /dev/null +++ b/lib/archer/kotlin_parser/KotlinParser.interp @@ -0,0 +1,529 @@ +token literal names: +null +null +null +null +null +null +'...' +'.' +',' +'(' +')' +'[' +']' +'{' +'}' +'*' +'%' +'/' +'+' +'-' +'++' +'--' +'&&' +'||' +null +'!' +':' +';' +'=' +'+=' +'-=' +'*=' +'/=' +'%=' +'->' +'=>' +'..' +'::' +';;' +'#' +'@' +null +null +null +null +'?' +'<' +'>' +'<=' +'>=' +'!=' +'!==' +'as?' +'==' +'===' +'\'' +'&' +null +null +null +null +null +'file' +'field' +'property' +'get' +'set' +'receiver' +'param' +'setparam' +'delegate' +'package' +'import' +'class' +'interface' +'fun' +'object' +'val' +'var' +'typealias' +'constructor' +'by' +'companion' +'init' +'this' +'super' +'typeof' +'where' +'if' +'else' +'when' +'try' +'catch' +'finally' +'for' +'do' +'while' +'throw' +'return' +'continue' +'break' +'as' +'is' +'in' +null +null +'out' +'dynamic' +'public' +'private' +'protected' +'internal' +'enum' +'sealed' +'annotation' +'data' +'inner' +'value' +'tailrec' +'operator' +'inline' +'infix' +'external' +'suspend' +'override' +'abstract' +'final' +'open' +'const' +'lateinit' +'vararg' +'noinline' +'crossinline' +'reified' +'expect' +'actual' +null +null +null +null +null +null +null +null +null +'null' +null +null +null +null +null +'"""' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +ShebangLine +DelimitedComment +LineComment +WS +NL +RESERVED +DOT +COMMA +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURL +RCURL +MULT +MOD +DIV +ADD +SUB +INCR +DECR +CONJ +DISJ +EXCL_WS +EXCL_NO_WS +COLON +SEMICOLON +ASSIGNMENT +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MULT_ASSIGNMENT +DIV_ASSIGNMENT +MOD_ASSIGNMENT +ARROW +DOUBLE_ARROW +RANGE +COLONCOLON +DOUBLE_SEMICOLON +HASH +AT_NO_WS +AT_POST_WS +AT_PRE_WS +AT_BOTH_WS +QUEST_WS +QUEST_NO_WS +LANGLE +RANGLE +LE +GE +EXCL_EQ +EXCL_EQEQ +AS_SAFE +EQEQ +EQEQEQ +SINGLE_QUOTE +AMP +RETURN_AT +CONTINUE_AT +BREAK_AT +THIS_AT +SUPER_AT +FILE +FIELD +PROPERTY +GET +SET +RECEIVER +PARAM +SETPARAM +DELEGATE +PACKAGE +IMPORT +CLASS +INTERFACE +FUN +OBJECT +VAL +VAR +TYPE_ALIAS +CONSTRUCTOR +BY +COMPANION +INIT +THIS +SUPER +TYPEOF +WHERE +IF +ELSE +WHEN +TRY +CATCH +FINALLY +FOR +DO +WHILE +THROW +RETURN +CONTINUE +BREAK +AS +IS +IN +NOT_IS +NOT_IN +OUT +DYNAMIC +PUBLIC +PRIVATE +PROTECTED +INTERNAL +ENUM +SEALED +ANNOTATION +DATA +INNER +VALUE +TAILREC +OPERATOR +INLINE +INFIX +EXTERNAL +SUSPEND +OVERRIDE +ABSTRACT +FINAL +OPEN +CONST +LATEINIT +VARARG +NOINLINE +CROSSINLINE +REIFIED +EXPECT +ACTUAL +RealLiteral +FloatLiteral +DoubleLiteral +IntegerLiteral +HexLiteral +BinLiteral +UnsignedLiteral +LongLiteral +BooleanLiteral +NullLiteral +CharacterLiteral +Identifier +IdentifierOrSoftKey +FieldIdentifier +QUOTE_OPEN +TRIPLE_QUOTE_OPEN +UNICODE_CLASS_LL +UNICODE_CLASS_LM +UNICODE_CLASS_LO +UNICODE_CLASS_LT +UNICODE_CLASS_LU +UNICODE_CLASS_ND +UNICODE_CLASS_NL +QUOTE_CLOSE +LineStrRef +LineStrText +LineStrEscapedChar +LineStrExprStart +TRIPLE_QUOTE_CLOSE +MultiLineStringQuote +MultiLineStrRef +MultiLineStrText +MultiLineStrExprStart +Inside_Comment +Inside_WS +Inside_NL +ErrorCharacter + +rule names: +kotlinFile +script +shebangLine +fileAnnotation +packageHeader +importList +importHeader +importAlias +topLevelObject +typeAlias +declaration +classDeclaration +primaryConstructor +classBody +classParameters +classParameter +delegationSpecifiers +delegationSpecifier +constructorInvocation +annotatedDelegationSpecifier +explicitDelegation +typeParameters +typeParameter +typeConstraints +typeConstraint +classMemberDeclarations +classMemberDeclaration +anonymousInitializer +companionObject +functionValueParameters +functionValueParameter +functionDeclaration +functionBody +variableDeclaration +multiVariableDeclaration +propertyDeclaration +propertyDelegate +getter +setter +parametersWithOptionalType +functionValueParameterWithOptionalType +parameterWithOptionalType +parameter +objectDeclaration +secondaryConstructor +constructorDelegationCall +enumClassBody +enumEntries +enumEntry +type +typeReference +nullableType +quest +userType +simpleUserType +typeProjection +typeProjectionModifiers +typeProjectionModifier +functionType +functionTypeParameters +parenthesizedType +receiverType +parenthesizedUserType +definitelyNonNullableType +statements +statement +label +controlStructureBody +block +loopStatement +forStatement +whileStatement +doWhileStatement +assignment +semi +semis +expression +disjunction +conjunction +equality +comparison +genericCallLikeComparison +infixOperation +elvisExpression +elvis +infixFunctionCall +rangeExpression +additiveExpression +multiplicativeExpression +asExpression +prefixUnaryExpression +unaryPrefix +postfixUnaryExpression +postfixUnarySuffix +directlyAssignableExpression +parenthesizedDirectlyAssignableExpression +assignableExpression +parenthesizedAssignableExpression +assignableSuffix +indexingSuffix +navigationSuffix +callSuffix +annotatedLambda +typeArguments +valueArguments +valueArgument +primaryExpression +parenthesizedExpression +collectionLiteral +literalConstant +stringLiteral +lineStringLiteral +multiLineStringLiteral +lineStringContent +lineStringExpression +multiLineStringContent +multiLineStringExpression +lambdaLiteral +lambdaParameters +lambdaParameter +anonymousFunction +functionLiteral +objectLiteral +thisExpression +superExpression +ifExpression +whenSubject +whenExpression +whenEntry +whenCondition +rangeTest +typeTest +tryExpression +catchBlock +finallyBlock +jumpExpression +callableReference +assignmentAndOperator +equalityOperator +comparisonOperator +inOperator +isOperator +additiveOperator +multiplicativeOperator +asOperator +prefixUnaryOperator +postfixUnaryOperator +excl +memberAccessOperator +safeNav +modifiers +parameterModifiers +modifier +typeModifiers +typeModifier +classModifier +memberModifier +visibilityModifier +varianceModifier +typeParameterModifiers +typeParameterModifier +functionModifier +propertyModifier +inheritanceModifier +parameterModifier +reificationModifier +platformModifier +annotation +singleAnnotation +multiAnnotation +annotationUseSiteTarget +unescapedAnnotation +simpleIdentifier +identifier + + +atn: +[4, 1, 172, 3486, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 1, 0, 3, 0, 350, 8, 0, 1, 0, 5, 0, 353, 8, 0, 10, 0, 12, 0, 356, 9, 0, 1, 0, 5, 0, 359, 8, 0, 10, 0, 12, 0, 362, 9, 0, 1, 0, 1, 0, 1, 0, 5, 0, 367, 8, 0, 10, 0, 12, 0, 370, 9, 0, 1, 0, 1, 0, 1, 1, 3, 1, 375, 8, 1, 1, 1, 5, 1, 378, 8, 1, 10, 1, 12, 1, 381, 9, 1, 1, 1, 5, 1, 384, 8, 1, 10, 1, 12, 1, 387, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 394, 8, 1, 10, 1, 12, 1, 397, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2, 4, 2, 403, 8, 2, 11, 2, 12, 2, 404, 1, 3, 1, 3, 1, 3, 5, 3, 410, 8, 3, 10, 3, 12, 3, 413, 9, 3, 1, 3, 1, 3, 5, 3, 417, 8, 3, 10, 3, 12, 3, 420, 9, 3, 1, 3, 1, 3, 4, 3, 424, 8, 3, 11, 3, 12, 3, 425, 1, 3, 1, 3, 1, 3, 3, 3, 431, 8, 3, 1, 3, 5, 3, 434, 8, 3, 10, 3, 12, 3, 437, 9, 3, 1, 4, 1, 4, 1, 4, 3, 4, 442, 8, 4, 3, 4, 444, 8, 4, 1, 5, 5, 5, 447, 8, 5, 10, 5, 12, 5, 450, 9, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 457, 8, 6, 1, 6, 3, 6, 460, 8, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 467, 8, 8, 1, 9, 3, 9, 470, 8, 9, 1, 9, 1, 9, 5, 9, 474, 8, 9, 10, 9, 12, 9, 477, 9, 9, 1, 9, 1, 9, 5, 9, 481, 8, 9, 10, 9, 12, 9, 484, 9, 9, 1, 9, 3, 9, 487, 8, 9, 1, 9, 5, 9, 490, 8, 9, 10, 9, 12, 9, 493, 9, 9, 1, 9, 1, 9, 5, 9, 497, 8, 9, 10, 9, 12, 9, 500, 9, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 509, 8, 10, 1, 11, 3, 11, 512, 8, 11, 1, 11, 1, 11, 1, 11, 5, 11, 517, 8, 11, 10, 11, 12, 11, 520, 9, 11, 3, 11, 522, 8, 11, 1, 11, 3, 11, 525, 8, 11, 1, 11, 5, 11, 528, 8, 11, 10, 11, 12, 11, 531, 9, 11, 1, 11, 1, 11, 5, 11, 535, 8, 11, 10, 11, 12, 11, 538, 9, 11, 1, 11, 3, 11, 541, 8, 11, 1, 11, 5, 11, 544, 8, 11, 10, 11, 12, 11, 547, 9, 11, 1, 11, 3, 11, 550, 8, 11, 1, 11, 5, 11, 553, 8, 11, 10, 11, 12, 11, 556, 9, 11, 1, 11, 1, 11, 5, 11, 560, 8, 11, 10, 11, 12, 11, 563, 9, 11, 1, 11, 3, 11, 566, 8, 11, 1, 11, 5, 11, 569, 8, 11, 10, 11, 12, 11, 572, 9, 11, 1, 11, 3, 11, 575, 8, 11, 1, 11, 5, 11, 578, 8, 11, 10, 11, 12, 11, 581, 9, 11, 1, 11, 1, 11, 5, 11, 585, 8, 11, 10, 11, 12, 11, 588, 9, 11, 1, 11, 3, 11, 591, 8, 11, 1, 12, 3, 12, 594, 8, 12, 1, 12, 1, 12, 5, 12, 598, 8, 12, 10, 12, 12, 12, 601, 9, 12, 3, 12, 603, 8, 12, 1, 12, 1, 12, 1, 13, 1, 13, 5, 13, 609, 8, 13, 10, 13, 12, 13, 612, 9, 13, 1, 13, 1, 13, 5, 13, 616, 8, 13, 10, 13, 12, 13, 619, 9, 13, 1, 13, 1, 13, 1, 14, 1, 14, 5, 14, 625, 8, 14, 10, 14, 12, 14, 628, 9, 14, 1, 14, 1, 14, 5, 14, 632, 8, 14, 10, 14, 12, 14, 635, 9, 14, 1, 14, 1, 14, 5, 14, 639, 8, 14, 10, 14, 12, 14, 642, 9, 14, 1, 14, 5, 14, 645, 8, 14, 10, 14, 12, 14, 648, 9, 14, 1, 14, 5, 14, 651, 8, 14, 10, 14, 12, 14, 654, 9, 14, 1, 14, 3, 14, 657, 8, 14, 3, 14, 659, 8, 14, 1, 14, 5, 14, 662, 8, 14, 10, 14, 12, 14, 665, 9, 14, 1, 14, 1, 14, 1, 15, 3, 15, 670, 8, 15, 1, 15, 3, 15, 673, 8, 15, 1, 15, 5, 15, 676, 8, 15, 10, 15, 12, 15, 679, 9, 15, 1, 15, 1, 15, 1, 15, 5, 15, 684, 8, 15, 10, 15, 12, 15, 687, 9, 15, 1, 15, 1, 15, 5, 15, 691, 8, 15, 10, 15, 12, 15, 694, 9, 15, 1, 15, 1, 15, 5, 15, 698, 8, 15, 10, 15, 12, 15, 701, 9, 15, 1, 15, 3, 15, 704, 8, 15, 1, 16, 1, 16, 5, 16, 708, 8, 16, 10, 16, 12, 16, 711, 9, 16, 1, 16, 1, 16, 5, 16, 715, 8, 16, 10, 16, 12, 16, 718, 9, 16, 1, 16, 5, 16, 721, 8, 16, 10, 16, 12, 16, 724, 9, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 5, 17, 732, 8, 17, 10, 17, 12, 17, 735, 9, 17, 1, 17, 3, 17, 738, 8, 17, 1, 18, 1, 18, 1, 18, 1, 19, 5, 19, 744, 8, 19, 10, 19, 12, 19, 747, 9, 19, 1, 19, 5, 19, 750, 8, 19, 10, 19, 12, 19, 753, 9, 19, 1, 19, 1, 19, 1, 20, 1, 20, 3, 20, 759, 8, 20, 1, 20, 5, 20, 762, 8, 20, 10, 20, 12, 20, 765, 9, 20, 1, 20, 1, 20, 5, 20, 769, 8, 20, 10, 20, 12, 20, 772, 9, 20, 1, 20, 1, 20, 1, 21, 1, 21, 5, 21, 778, 8, 21, 10, 21, 12, 21, 781, 9, 21, 1, 21, 1, 21, 5, 21, 785, 8, 21, 10, 21, 12, 21, 788, 9, 21, 1, 21, 1, 21, 5, 21, 792, 8, 21, 10, 21, 12, 21, 795, 9, 21, 1, 21, 5, 21, 798, 8, 21, 10, 21, 12, 21, 801, 9, 21, 1, 21, 5, 21, 804, 8, 21, 10, 21, 12, 21, 807, 9, 21, 1, 21, 3, 21, 810, 8, 21, 1, 21, 5, 21, 813, 8, 21, 10, 21, 12, 21, 816, 9, 21, 1, 21, 1, 21, 1, 22, 3, 22, 821, 8, 22, 1, 22, 5, 22, 824, 8, 22, 10, 22, 12, 22, 827, 9, 22, 1, 22, 1, 22, 5, 22, 831, 8, 22, 10, 22, 12, 22, 834, 9, 22, 1, 22, 1, 22, 5, 22, 838, 8, 22, 10, 22, 12, 22, 841, 9, 22, 1, 22, 3, 22, 844, 8, 22, 1, 23, 1, 23, 5, 23, 848, 8, 23, 10, 23, 12, 23, 851, 9, 23, 1, 23, 1, 23, 5, 23, 855, 8, 23, 10, 23, 12, 23, 858, 9, 23, 1, 23, 1, 23, 5, 23, 862, 8, 23, 10, 23, 12, 23, 865, 9, 23, 1, 23, 5, 23, 868, 8, 23, 10, 23, 12, 23, 871, 9, 23, 1, 24, 5, 24, 874, 8, 24, 10, 24, 12, 24, 877, 9, 24, 1, 24, 1, 24, 5, 24, 881, 8, 24, 10, 24, 12, 24, 884, 9, 24, 1, 24, 1, 24, 5, 24, 888, 8, 24, 10, 24, 12, 24, 891, 9, 24, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 897, 8, 25, 5, 25, 899, 8, 25, 10, 25, 12, 25, 902, 9, 25, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 908, 8, 26, 1, 27, 1, 27, 5, 27, 912, 8, 27, 10, 27, 12, 27, 915, 9, 27, 1, 27, 1, 27, 1, 28, 3, 28, 920, 8, 28, 1, 28, 1, 28, 5, 28, 924, 8, 28, 10, 28, 12, 28, 927, 9, 28, 1, 28, 1, 28, 5, 28, 931, 8, 28, 10, 28, 12, 28, 934, 9, 28, 1, 28, 3, 28, 937, 8, 28, 1, 28, 5, 28, 940, 8, 28, 10, 28, 12, 28, 943, 9, 28, 1, 28, 1, 28, 5, 28, 947, 8, 28, 10, 28, 12, 28, 950, 9, 28, 1, 28, 3, 28, 953, 8, 28, 1, 28, 5, 28, 956, 8, 28, 10, 28, 12, 28, 959, 9, 28, 1, 28, 3, 28, 962, 8, 28, 1, 29, 1, 29, 5, 29, 966, 8, 29, 10, 29, 12, 29, 969, 9, 29, 1, 29, 1, 29, 5, 29, 973, 8, 29, 10, 29, 12, 29, 976, 9, 29, 1, 29, 1, 29, 5, 29, 980, 8, 29, 10, 29, 12, 29, 983, 9, 29, 1, 29, 5, 29, 986, 8, 29, 10, 29, 12, 29, 989, 9, 29, 1, 29, 5, 29, 992, 8, 29, 10, 29, 12, 29, 995, 9, 29, 1, 29, 3, 29, 998, 8, 29, 3, 29, 1000, 8, 29, 1, 29, 5, 29, 1003, 8, 29, 10, 29, 12, 29, 1006, 9, 29, 1, 29, 1, 29, 1, 30, 3, 30, 1011, 8, 30, 1, 30, 1, 30, 5, 30, 1015, 8, 30, 10, 30, 12, 30, 1018, 9, 30, 1, 30, 1, 30, 5, 30, 1022, 8, 30, 10, 30, 12, 30, 1025, 9, 30, 1, 30, 3, 30, 1028, 8, 30, 1, 31, 3, 31, 1031, 8, 31, 1, 31, 1, 31, 5, 31, 1035, 8, 31, 10, 31, 12, 31, 1038, 9, 31, 1, 31, 3, 31, 1041, 8, 31, 1, 31, 5, 31, 1044, 8, 31, 10, 31, 12, 31, 1047, 9, 31, 1, 31, 1, 31, 5, 31, 1051, 8, 31, 10, 31, 12, 31, 1054, 9, 31, 1, 31, 1, 31, 3, 31, 1058, 8, 31, 1, 31, 5, 31, 1061, 8, 31, 10, 31, 12, 31, 1064, 9, 31, 1, 31, 1, 31, 5, 31, 1068, 8, 31, 10, 31, 12, 31, 1071, 9, 31, 1, 31, 1, 31, 5, 31, 1075, 8, 31, 10, 31, 12, 31, 1078, 9, 31, 1, 31, 1, 31, 5, 31, 1082, 8, 31, 10, 31, 12, 31, 1085, 9, 31, 1, 31, 3, 31, 1088, 8, 31, 1, 31, 5, 31, 1091, 8, 31, 10, 31, 12, 31, 1094, 9, 31, 1, 31, 3, 31, 1097, 8, 31, 1, 31, 5, 31, 1100, 8, 31, 10, 31, 12, 31, 1103, 9, 31, 1, 31, 3, 31, 1106, 8, 31, 1, 32, 1, 32, 1, 32, 5, 32, 1111, 8, 32, 10, 32, 12, 32, 1114, 9, 32, 1, 32, 3, 32, 1117, 8, 32, 1, 33, 5, 33, 1120, 8, 33, 10, 33, 12, 33, 1123, 9, 33, 1, 33, 5, 33, 1126, 8, 33, 10, 33, 12, 33, 1129, 9, 33, 1, 33, 1, 33, 5, 33, 1133, 8, 33, 10, 33, 12, 33, 1136, 9, 33, 1, 33, 1, 33, 5, 33, 1140, 8, 33, 10, 33, 12, 33, 1143, 9, 33, 1, 33, 3, 33, 1146, 8, 33, 1, 34, 1, 34, 5, 34, 1150, 8, 34, 10, 34, 12, 34, 1153, 9, 34, 1, 34, 1, 34, 5, 34, 1157, 8, 34, 10, 34, 12, 34, 1160, 9, 34, 1, 34, 1, 34, 5, 34, 1164, 8, 34, 10, 34, 12, 34, 1167, 9, 34, 1, 34, 5, 34, 1170, 8, 34, 10, 34, 12, 34, 1173, 9, 34, 1, 34, 5, 34, 1176, 8, 34, 10, 34, 12, 34, 1179, 9, 34, 1, 34, 3, 34, 1182, 8, 34, 1, 34, 5, 34, 1185, 8, 34, 10, 34, 12, 34, 1188, 9, 34, 1, 34, 1, 34, 1, 35, 3, 35, 1193, 8, 35, 1, 35, 1, 35, 5, 35, 1197, 8, 35, 10, 35, 12, 35, 1200, 9, 35, 1, 35, 3, 35, 1203, 8, 35, 1, 35, 5, 35, 1206, 8, 35, 10, 35, 12, 35, 1209, 9, 35, 1, 35, 1, 35, 5, 35, 1213, 8, 35, 10, 35, 12, 35, 1216, 9, 35, 1, 35, 1, 35, 3, 35, 1220, 8, 35, 1, 35, 5, 35, 1223, 8, 35, 10, 35, 12, 35, 1226, 9, 35, 1, 35, 1, 35, 3, 35, 1230, 8, 35, 1, 35, 5, 35, 1233, 8, 35, 10, 35, 12, 35, 1236, 9, 35, 1, 35, 3, 35, 1239, 8, 35, 1, 35, 5, 35, 1242, 8, 35, 10, 35, 12, 35, 1245, 9, 35, 1, 35, 1, 35, 5, 35, 1249, 8, 35, 10, 35, 12, 35, 1252, 9, 35, 1, 35, 1, 35, 3, 35, 1256, 8, 35, 3, 35, 1258, 8, 35, 1, 35, 4, 35, 1261, 8, 35, 11, 35, 12, 35, 1262, 1, 35, 3, 35, 1266, 8, 35, 1, 35, 5, 35, 1269, 8, 35, 10, 35, 12, 35, 1272, 9, 35, 1, 35, 3, 35, 1275, 8, 35, 1, 35, 5, 35, 1278, 8, 35, 10, 35, 12, 35, 1281, 9, 35, 1, 35, 3, 35, 1284, 8, 35, 1, 35, 3, 35, 1287, 8, 35, 1, 35, 3, 35, 1290, 8, 35, 1, 35, 5, 35, 1293, 8, 35, 10, 35, 12, 35, 1296, 9, 35, 1, 35, 3, 35, 1299, 8, 35, 1, 35, 3, 35, 1302, 8, 35, 3, 35, 1304, 8, 35, 1, 36, 1, 36, 5, 36, 1308, 8, 36, 10, 36, 12, 36, 1311, 9, 36, 1, 36, 1, 36, 1, 37, 3, 37, 1316, 8, 37, 1, 37, 1, 37, 5, 37, 1320, 8, 37, 10, 37, 12, 37, 1323, 9, 37, 1, 37, 1, 37, 5, 37, 1327, 8, 37, 10, 37, 12, 37, 1330, 9, 37, 1, 37, 1, 37, 5, 37, 1334, 8, 37, 10, 37, 12, 37, 1337, 9, 37, 1, 37, 1, 37, 5, 37, 1341, 8, 37, 10, 37, 12, 37, 1344, 9, 37, 1, 37, 3, 37, 1347, 8, 37, 1, 37, 5, 37, 1350, 8, 37, 10, 37, 12, 37, 1353, 9, 37, 1, 37, 3, 37, 1356, 8, 37, 1, 38, 3, 38, 1359, 8, 38, 1, 38, 1, 38, 5, 38, 1363, 8, 38, 10, 38, 12, 38, 1366, 9, 38, 1, 38, 1, 38, 5, 38, 1370, 8, 38, 10, 38, 12, 38, 1373, 9, 38, 1, 38, 1, 38, 5, 38, 1377, 8, 38, 10, 38, 12, 38, 1380, 9, 38, 1, 38, 3, 38, 1383, 8, 38, 1, 38, 5, 38, 1386, 8, 38, 10, 38, 12, 38, 1389, 9, 38, 1, 38, 1, 38, 5, 38, 1393, 8, 38, 10, 38, 12, 38, 1396, 9, 38, 1, 38, 1, 38, 5, 38, 1400, 8, 38, 10, 38, 12, 38, 1403, 9, 38, 1, 38, 3, 38, 1406, 8, 38, 1, 38, 5, 38, 1409, 8, 38, 10, 38, 12, 38, 1412, 9, 38, 1, 38, 1, 38, 3, 38, 1416, 8, 38, 1, 39, 1, 39, 5, 39, 1420, 8, 39, 10, 39, 12, 39, 1423, 9, 39, 1, 39, 1, 39, 5, 39, 1427, 8, 39, 10, 39, 12, 39, 1430, 9, 39, 1, 39, 1, 39, 5, 39, 1434, 8, 39, 10, 39, 12, 39, 1437, 9, 39, 1, 39, 5, 39, 1440, 8, 39, 10, 39, 12, 39, 1443, 9, 39, 1, 39, 5, 39, 1446, 8, 39, 10, 39, 12, 39, 1449, 9, 39, 1, 39, 3, 39, 1452, 8, 39, 3, 39, 1454, 8, 39, 1, 39, 5, 39, 1457, 8, 39, 10, 39, 12, 39, 1460, 9, 39, 1, 39, 1, 39, 1, 40, 3, 40, 1465, 8, 40, 1, 40, 1, 40, 5, 40, 1469, 8, 40, 10, 40, 12, 40, 1472, 9, 40, 1, 40, 1, 40, 5, 40, 1476, 8, 40, 10, 40, 12, 40, 1479, 9, 40, 1, 40, 3, 40, 1482, 8, 40, 1, 41, 1, 41, 5, 41, 1486, 8, 41, 10, 41, 12, 41, 1489, 9, 41, 1, 41, 1, 41, 5, 41, 1493, 8, 41, 10, 41, 12, 41, 1496, 9, 41, 1, 41, 3, 41, 1499, 8, 41, 1, 42, 1, 42, 5, 42, 1503, 8, 42, 10, 42, 12, 42, 1506, 9, 42, 1, 42, 1, 42, 5, 42, 1510, 8, 42, 10, 42, 12, 42, 1513, 9, 42, 1, 42, 1, 42, 1, 43, 3, 43, 1518, 8, 43, 1, 43, 1, 43, 5, 43, 1522, 8, 43, 10, 43, 12, 43, 1525, 9, 43, 1, 43, 1, 43, 5, 43, 1529, 8, 43, 10, 43, 12, 43, 1532, 9, 43, 1, 43, 1, 43, 5, 43, 1536, 8, 43, 10, 43, 12, 43, 1539, 9, 43, 1, 43, 3, 43, 1542, 8, 43, 1, 43, 5, 43, 1545, 8, 43, 10, 43, 12, 43, 1548, 9, 43, 1, 43, 3, 43, 1551, 8, 43, 1, 44, 3, 44, 1554, 8, 44, 1, 44, 1, 44, 5, 44, 1558, 8, 44, 10, 44, 12, 44, 1561, 9, 44, 1, 44, 1, 44, 5, 44, 1565, 8, 44, 10, 44, 12, 44, 1568, 9, 44, 1, 44, 1, 44, 5, 44, 1572, 8, 44, 10, 44, 12, 44, 1575, 9, 44, 1, 44, 3, 44, 1578, 8, 44, 1, 44, 5, 44, 1581, 8, 44, 10, 44, 12, 44, 1584, 9, 44, 1, 44, 3, 44, 1587, 8, 44, 1, 45, 1, 45, 5, 45, 1591, 8, 45, 10, 45, 12, 45, 1594, 9, 45, 1, 45, 1, 45, 1, 46, 1, 46, 5, 46, 1600, 8, 46, 10, 46, 12, 46, 1603, 9, 46, 1, 46, 3, 46, 1606, 8, 46, 1, 46, 5, 46, 1609, 8, 46, 10, 46, 12, 46, 1612, 9, 46, 1, 46, 1, 46, 5, 46, 1616, 8, 46, 10, 46, 12, 46, 1619, 9, 46, 1, 46, 3, 46, 1622, 8, 46, 1, 46, 5, 46, 1625, 8, 46, 10, 46, 12, 46, 1628, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 5, 47, 1634, 8, 47, 10, 47, 12, 47, 1637, 9, 47, 1, 47, 1, 47, 5, 47, 1641, 8, 47, 10, 47, 12, 47, 1644, 9, 47, 1, 47, 5, 47, 1647, 8, 47, 10, 47, 12, 47, 1650, 9, 47, 1, 47, 5, 47, 1653, 8, 47, 10, 47, 12, 47, 1656, 9, 47, 1, 47, 3, 47, 1659, 8, 47, 1, 48, 1, 48, 5, 48, 1663, 8, 48, 10, 48, 12, 48, 1666, 9, 48, 3, 48, 1668, 8, 48, 1, 48, 1, 48, 5, 48, 1672, 8, 48, 10, 48, 12, 48, 1675, 9, 48, 1, 48, 3, 48, 1678, 8, 48, 1, 48, 5, 48, 1681, 8, 48, 10, 48, 12, 48, 1684, 9, 48, 1, 48, 3, 48, 1687, 8, 48, 1, 49, 3, 49, 1690, 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1697, 8, 49, 1, 50, 1, 50, 3, 50, 1701, 8, 50, 1, 51, 1, 51, 3, 51, 1705, 8, 51, 1, 51, 5, 51, 1708, 8, 51, 10, 51, 12, 51, 1711, 9, 51, 1, 51, 4, 51, 1714, 8, 51, 11, 51, 12, 51, 1715, 1, 52, 1, 52, 1, 53, 1, 53, 5, 53, 1722, 8, 53, 10, 53, 12, 53, 1725, 9, 53, 1, 53, 1, 53, 5, 53, 1729, 8, 53, 10, 53, 12, 53, 1732, 9, 53, 1, 53, 5, 53, 1735, 8, 53, 10, 53, 12, 53, 1738, 9, 53, 1, 54, 1, 54, 5, 54, 1742, 8, 54, 10, 54, 12, 54, 1745, 9, 54, 1, 54, 3, 54, 1748, 8, 54, 1, 55, 3, 55, 1751, 8, 55, 1, 55, 1, 55, 3, 55, 1755, 8, 55, 1, 56, 4, 56, 1758, 8, 56, 11, 56, 12, 56, 1759, 1, 57, 1, 57, 5, 57, 1764, 8, 57, 10, 57, 12, 57, 1767, 9, 57, 1, 57, 3, 57, 1770, 8, 57, 1, 58, 1, 58, 5, 58, 1774, 8, 58, 10, 58, 12, 58, 1777, 9, 58, 1, 58, 1, 58, 5, 58, 1781, 8, 58, 10, 58, 12, 58, 1784, 9, 58, 3, 58, 1786, 8, 58, 1, 58, 1, 58, 5, 58, 1790, 8, 58, 10, 58, 12, 58, 1793, 9, 58, 1, 58, 1, 58, 5, 58, 1797, 8, 58, 10, 58, 12, 58, 1800, 9, 58, 1, 58, 1, 58, 1, 59, 1, 59, 5, 59, 1806, 8, 59, 10, 59, 12, 59, 1809, 9, 59, 1, 59, 1, 59, 3, 59, 1813, 8, 59, 1, 59, 5, 59, 1816, 8, 59, 10, 59, 12, 59, 1819, 9, 59, 1, 59, 1, 59, 5, 59, 1823, 8, 59, 10, 59, 12, 59, 1826, 9, 59, 1, 59, 1, 59, 3, 59, 1830, 8, 59, 5, 59, 1832, 8, 59, 10, 59, 12, 59, 1835, 9, 59, 1, 59, 5, 59, 1838, 8, 59, 10, 59, 12, 59, 1841, 9, 59, 1, 59, 3, 59, 1844, 8, 59, 1, 59, 5, 59, 1847, 8, 59, 10, 59, 12, 59, 1850, 9, 59, 1, 59, 1, 59, 1, 60, 1, 60, 5, 60, 1856, 8, 60, 10, 60, 12, 60, 1859, 9, 60, 1, 60, 1, 60, 5, 60, 1863, 8, 60, 10, 60, 12, 60, 1866, 9, 60, 1, 60, 1, 60, 1, 61, 3, 61, 1871, 8, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1876, 8, 61, 1, 62, 1, 62, 5, 62, 1880, 8, 62, 10, 62, 12, 62, 1883, 9, 62, 1, 62, 1, 62, 3, 62, 1887, 8, 62, 1, 62, 5, 62, 1890, 8, 62, 10, 62, 12, 62, 1893, 9, 62, 1, 62, 1, 62, 1, 63, 3, 63, 1898, 8, 63, 1, 63, 1, 63, 3, 63, 1902, 8, 63, 1, 63, 5, 63, 1905, 8, 63, 10, 63, 12, 63, 1908, 9, 63, 1, 63, 1, 63, 5, 63, 1912, 8, 63, 10, 63, 12, 63, 1915, 9, 63, 1, 63, 3, 63, 1918, 8, 63, 1, 63, 1, 63, 3, 63, 1922, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 1928, 8, 64, 10, 64, 12, 64, 1931, 9, 64, 3, 64, 1933, 8, 64, 1, 64, 3, 64, 1936, 8, 64, 1, 65, 1, 65, 5, 65, 1940, 8, 65, 10, 65, 12, 65, 1943, 9, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1949, 8, 65, 1, 66, 1, 66, 1, 66, 5, 66, 1954, 8, 66, 10, 66, 12, 66, 1957, 9, 66, 1, 67, 1, 67, 3, 67, 1961, 8, 67, 1, 68, 1, 68, 5, 68, 1965, 8, 68, 10, 68, 12, 68, 1968, 9, 68, 1, 68, 1, 68, 5, 68, 1972, 8, 68, 10, 68, 12, 68, 1975, 9, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1982, 8, 69, 1, 70, 1, 70, 5, 70, 1986, 8, 70, 10, 70, 12, 70, 1989, 9, 70, 1, 70, 1, 70, 5, 70, 1993, 8, 70, 10, 70, 12, 70, 1996, 9, 70, 1, 70, 1, 70, 3, 70, 2000, 8, 70, 1, 70, 1, 70, 1, 70, 1, 70, 5, 70, 2006, 8, 70, 10, 70, 12, 70, 2009, 9, 70, 1, 70, 3, 70, 2012, 8, 70, 1, 71, 1, 71, 5, 71, 2016, 8, 71, 10, 71, 12, 71, 2019, 9, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2025, 8, 71, 10, 71, 12, 71, 2028, 9, 71, 1, 71, 1, 71, 3, 71, 2032, 8, 71, 1, 72, 1, 72, 5, 72, 2036, 8, 72, 10, 72, 12, 72, 2039, 9, 72, 1, 72, 3, 72, 2042, 8, 72, 1, 72, 5, 72, 2045, 8, 72, 10, 72, 12, 72, 2048, 9, 72, 1, 72, 1, 72, 5, 72, 2052, 8, 72, 10, 72, 12, 72, 2055, 9, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2067, 8, 73, 1, 73, 5, 73, 2070, 8, 73, 10, 73, 12, 73, 2073, 9, 73, 1, 73, 1, 73, 1, 74, 1, 74, 5, 74, 2079, 8, 74, 10, 74, 12, 74, 2082, 9, 74, 1, 75, 4, 75, 2085, 8, 75, 11, 75, 12, 75, 2086, 1, 76, 1, 76, 1, 77, 1, 77, 5, 77, 2093, 8, 77, 10, 77, 12, 77, 2096, 9, 77, 1, 77, 1, 77, 5, 77, 2100, 8, 77, 10, 77, 12, 77, 2103, 9, 77, 1, 77, 5, 77, 2106, 8, 77, 10, 77, 12, 77, 2109, 9, 77, 1, 78, 1, 78, 5, 78, 2113, 8, 78, 10, 78, 12, 78, 2116, 9, 78, 1, 78, 1, 78, 5, 78, 2120, 8, 78, 10, 78, 12, 78, 2123, 9, 78, 1, 78, 5, 78, 2126, 8, 78, 10, 78, 12, 78, 2129, 9, 78, 1, 79, 1, 79, 1, 79, 5, 79, 2134, 8, 79, 10, 79, 12, 79, 2137, 9, 79, 1, 79, 1, 79, 5, 79, 2141, 8, 79, 10, 79, 12, 79, 2144, 9, 79, 1, 80, 1, 80, 1, 80, 5, 80, 2149, 8, 80, 10, 80, 12, 80, 2152, 9, 80, 1, 80, 1, 80, 5, 80, 2156, 8, 80, 10, 80, 12, 80, 2159, 9, 80, 1, 81, 1, 81, 5, 81, 2163, 8, 81, 10, 81, 12, 81, 2166, 9, 81, 1, 82, 1, 82, 1, 82, 5, 82, 2171, 8, 82, 10, 82, 12, 82, 2174, 9, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 2180, 8, 82, 10, 82, 12, 82, 2183, 9, 82, 1, 82, 1, 82, 5, 82, 2187, 8, 82, 10, 82, 12, 82, 2190, 9, 82, 1, 83, 1, 83, 5, 83, 2194, 8, 83, 10, 83, 12, 83, 2197, 9, 83, 1, 83, 1, 83, 5, 83, 2201, 8, 83, 10, 83, 12, 83, 2204, 9, 83, 1, 83, 1, 83, 5, 83, 2208, 8, 83, 10, 83, 12, 83, 2211, 9, 83, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 5, 85, 2219, 8, 85, 10, 85, 12, 85, 2222, 9, 85, 1, 85, 1, 85, 5, 85, 2226, 8, 85, 10, 85, 12, 85, 2229, 9, 85, 1, 86, 1, 86, 1, 86, 5, 86, 2234, 8, 86, 10, 86, 12, 86, 2237, 9, 86, 1, 86, 5, 86, 2240, 8, 86, 10, 86, 12, 86, 2243, 9, 86, 1, 87, 1, 87, 1, 87, 5, 87, 2248, 8, 87, 10, 87, 12, 87, 2251, 9, 87, 1, 87, 1, 87, 5, 87, 2255, 8, 87, 10, 87, 12, 87, 2258, 9, 87, 1, 88, 1, 88, 1, 88, 5, 88, 2263, 8, 88, 10, 88, 12, 88, 2266, 9, 88, 1, 88, 1, 88, 5, 88, 2270, 8, 88, 10, 88, 12, 88, 2273, 9, 88, 1, 89, 1, 89, 5, 89, 2277, 8, 89, 10, 89, 12, 89, 2280, 9, 89, 1, 89, 1, 89, 5, 89, 2284, 8, 89, 10, 89, 12, 89, 2287, 9, 89, 1, 89, 1, 89, 5, 89, 2291, 8, 89, 10, 89, 12, 89, 2294, 9, 89, 1, 90, 5, 90, 2297, 8, 90, 10, 90, 12, 90, 2300, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2308, 8, 91, 10, 91, 12, 91, 2311, 9, 91, 3, 91, 2313, 8, 91, 1, 92, 1, 92, 5, 92, 2317, 8, 92, 10, 92, 12, 92, 2320, 9, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 2327, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2334, 8, 94, 1, 95, 1, 95, 5, 95, 2338, 8, 95, 10, 95, 12, 95, 2341, 9, 95, 1, 95, 1, 95, 5, 95, 2345, 8, 95, 10, 95, 12, 95, 2348, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 3, 96, 2354, 8, 96, 1, 97, 1, 97, 5, 97, 2358, 8, 97, 10, 97, 12, 97, 2361, 9, 97, 1, 97, 1, 97, 5, 97, 2365, 8, 97, 10, 97, 12, 97, 2368, 9, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 3, 98, 2375, 8, 98, 1, 99, 1, 99, 5, 99, 2379, 8, 99, 10, 99, 12, 99, 2382, 9, 99, 1, 99, 1, 99, 5, 99, 2386, 8, 99, 10, 99, 12, 99, 2389, 9, 99, 1, 99, 1, 99, 5, 99, 2393, 8, 99, 10, 99, 12, 99, 2396, 9, 99, 1, 99, 5, 99, 2399, 8, 99, 10, 99, 12, 99, 2402, 9, 99, 1, 99, 5, 99, 2405, 8, 99, 10, 99, 12, 99, 2408, 9, 99, 1, 99, 3, 99, 2411, 8, 99, 1, 99, 5, 99, 2414, 8, 99, 10, 99, 12, 99, 2417, 9, 99, 1, 99, 1, 99, 1, 100, 1, 100, 5, 100, 2423, 8, 100, 10, 100, 12, 100, 2426, 9, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2431, 8, 100, 1, 101, 3, 101, 2434, 8, 101, 1, 101, 3, 101, 2437, 8, 101, 1, 101, 1, 101, 3, 101, 2441, 8, 101, 1, 102, 5, 102, 2444, 8, 102, 10, 102, 12, 102, 2447, 9, 102, 1, 102, 3, 102, 2450, 8, 102, 1, 102, 5, 102, 2453, 8, 102, 10, 102, 12, 102, 2456, 9, 102, 1, 102, 1, 102, 1, 103, 1, 103, 5, 103, 2462, 8, 103, 10, 103, 12, 103, 2465, 9, 103, 1, 103, 1, 103, 5, 103, 2469, 8, 103, 10, 103, 12, 103, 2472, 9, 103, 1, 103, 1, 103, 5, 103, 2476, 8, 103, 10, 103, 12, 103, 2479, 9, 103, 1, 103, 5, 103, 2482, 8, 103, 10, 103, 12, 103, 2485, 9, 103, 1, 103, 5, 103, 2488, 8, 103, 10, 103, 12, 103, 2491, 9, 103, 1, 103, 3, 103, 2494, 8, 103, 1, 103, 5, 103, 2497, 8, 103, 10, 103, 12, 103, 2500, 9, 103, 1, 103, 1, 103, 1, 104, 1, 104, 5, 104, 2506, 8, 104, 10, 104, 12, 104, 2509, 9, 104, 1, 104, 1, 104, 5, 104, 2513, 8, 104, 10, 104, 12, 104, 2516, 9, 104, 1, 104, 1, 104, 5, 104, 2520, 8, 104, 10, 104, 12, 104, 2523, 9, 104, 1, 104, 5, 104, 2526, 8, 104, 10, 104, 12, 104, 2529, 9, 104, 1, 104, 5, 104, 2532, 8, 104, 10, 104, 12, 104, 2535, 9, 104, 1, 104, 3, 104, 2538, 8, 104, 1, 104, 5, 104, 2541, 8, 104, 10, 104, 12, 104, 2544, 9, 104, 3, 104, 2546, 8, 104, 1, 104, 1, 104, 1, 105, 3, 105, 2551, 8, 105, 1, 105, 5, 105, 2554, 8, 105, 10, 105, 12, 105, 2557, 9, 105, 1, 105, 1, 105, 5, 105, 2561, 8, 105, 10, 105, 12, 105, 2564, 9, 105, 1, 105, 1, 105, 5, 105, 2568, 8, 105, 10, 105, 12, 105, 2571, 9, 105, 3, 105, 2573, 8, 105, 1, 105, 3, 105, 2576, 8, 105, 1, 105, 5, 105, 2579, 8, 105, 10, 105, 12, 105, 2582, 9, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2600, 8, 106, 1, 107, 1, 107, 5, 107, 2604, 8, 107, 10, 107, 12, 107, 2607, 9, 107, 1, 107, 1, 107, 5, 107, 2611, 8, 107, 10, 107, 12, 107, 2614, 9, 107, 1, 107, 1, 107, 1, 108, 1, 108, 5, 108, 2620, 8, 108, 10, 108, 12, 108, 2623, 9, 108, 1, 108, 1, 108, 5, 108, 2627, 8, 108, 10, 108, 12, 108, 2630, 9, 108, 1, 108, 1, 108, 5, 108, 2634, 8, 108, 10, 108, 12, 108, 2637, 9, 108, 1, 108, 5, 108, 2640, 8, 108, 10, 108, 12, 108, 2643, 9, 108, 1, 108, 5, 108, 2646, 8, 108, 10, 108, 12, 108, 2649, 9, 108, 1, 108, 3, 108, 2652, 8, 108, 1, 108, 5, 108, 2655, 8, 108, 10, 108, 12, 108, 2658, 9, 108, 3, 108, 2660, 8, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 3, 110, 2668, 8, 110, 1, 111, 1, 111, 1, 111, 5, 111, 2673, 8, 111, 10, 111, 12, 111, 2676, 9, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 2684, 8, 112, 10, 112, 12, 112, 2687, 9, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 114, 1, 114, 5, 114, 2695, 8, 114, 10, 114, 12, 114, 2698, 9, 114, 1, 114, 1, 114, 5, 114, 2702, 8, 114, 10, 114, 12, 114, 2705, 9, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 116, 1, 116, 5, 116, 2713, 8, 116, 10, 116, 12, 116, 2716, 9, 116, 1, 116, 1, 116, 5, 116, 2720, 8, 116, 10, 116, 12, 116, 2723, 9, 116, 1, 116, 1, 116, 1, 117, 1, 117, 5, 117, 2729, 8, 117, 10, 117, 12, 117, 2732, 9, 117, 1, 117, 3, 117, 2735, 8, 117, 1, 117, 5, 117, 2738, 8, 117, 10, 117, 12, 117, 2741, 9, 117, 1, 117, 1, 117, 5, 117, 2745, 8, 117, 10, 117, 12, 117, 2748, 9, 117, 3, 117, 2750, 8, 117, 1, 117, 1, 117, 5, 117, 2754, 8, 117, 10, 117, 12, 117, 2757, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 5, 118, 2763, 8, 118, 10, 118, 12, 118, 2766, 9, 118, 1, 118, 1, 118, 5, 118, 2770, 8, 118, 10, 118, 12, 118, 2773, 9, 118, 1, 118, 5, 118, 2776, 8, 118, 10, 118, 12, 118, 2779, 9, 118, 1, 118, 5, 118, 2782, 8, 118, 10, 118, 12, 118, 2785, 9, 118, 1, 118, 3, 118, 2788, 8, 118, 1, 119, 1, 119, 1, 119, 5, 119, 2793, 8, 119, 10, 119, 12, 119, 2796, 9, 119, 1, 119, 1, 119, 5, 119, 2800, 8, 119, 10, 119, 12, 119, 2803, 9, 119, 1, 119, 3, 119, 2806, 8, 119, 3, 119, 2808, 8, 119, 1, 120, 1, 120, 5, 120, 2812, 8, 120, 10, 120, 12, 120, 2815, 9, 120, 1, 120, 1, 120, 5, 120, 2819, 8, 120, 10, 120, 12, 120, 2822, 9, 120, 1, 120, 1, 120, 3, 120, 2826, 8, 120, 1, 120, 5, 120, 2829, 8, 120, 10, 120, 12, 120, 2832, 9, 120, 1, 120, 1, 120, 5, 120, 2836, 8, 120, 10, 120, 12, 120, 2839, 9, 120, 1, 120, 1, 120, 5, 120, 2843, 8, 120, 10, 120, 12, 120, 2846, 9, 120, 1, 120, 3, 120, 2849, 8, 120, 1, 120, 5, 120, 2852, 8, 120, 10, 120, 12, 120, 2855, 9, 120, 1, 120, 3, 120, 2858, 8, 120, 1, 120, 5, 120, 2861, 8, 120, 10, 120, 12, 120, 2864, 9, 120, 1, 120, 3, 120, 2867, 8, 120, 1, 121, 1, 121, 3, 121, 2871, 8, 121, 1, 122, 1, 122, 5, 122, 2875, 8, 122, 10, 122, 12, 122, 2878, 9, 122, 1, 122, 1, 122, 5, 122, 2882, 8, 122, 10, 122, 12, 122, 2885, 9, 122, 1, 122, 1, 122, 5, 122, 2889, 8, 122, 10, 122, 12, 122, 2892, 9, 122, 3, 122, 2894, 8, 122, 1, 122, 5, 122, 2897, 8, 122, 10, 122, 12, 122, 2900, 9, 122, 1, 122, 3, 122, 2903, 8, 122, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 5, 124, 2910, 8, 124, 10, 124, 12, 124, 2913, 9, 124, 1, 124, 1, 124, 5, 124, 2917, 8, 124, 10, 124, 12, 124, 2920, 9, 124, 1, 124, 1, 124, 3, 124, 2924, 8, 124, 1, 124, 1, 124, 3, 124, 2928, 8, 124, 1, 124, 3, 124, 2931, 8, 124, 1, 125, 1, 125, 5, 125, 2935, 8, 125, 10, 125, 12, 125, 2938, 9, 125, 1, 125, 1, 125, 5, 125, 2942, 8, 125, 10, 125, 12, 125, 2945, 9, 125, 1, 125, 1, 125, 5, 125, 2949, 8, 125, 10, 125, 12, 125, 2952, 9, 125, 1, 125, 1, 125, 5, 125, 2956, 8, 125, 10, 125, 12, 125, 2959, 9, 125, 1, 125, 1, 125, 3, 125, 2963, 8, 125, 1, 125, 5, 125, 2966, 8, 125, 10, 125, 12, 125, 2969, 9, 125, 1, 125, 3, 125, 2972, 8, 125, 1, 125, 5, 125, 2975, 8, 125, 10, 125, 12, 125, 2978, 9, 125, 1, 125, 1, 125, 5, 125, 2982, 8, 125, 10, 125, 12, 125, 2985, 9, 125, 1, 125, 1, 125, 3, 125, 2989, 8, 125, 1, 125, 3, 125, 2992, 8, 125, 1, 126, 1, 126, 5, 126, 2996, 8, 126, 10, 126, 12, 126, 2999, 9, 126, 1, 126, 5, 126, 3002, 8, 126, 10, 126, 12, 126, 3005, 9, 126, 1, 126, 1, 126, 5, 126, 3009, 8, 126, 10, 126, 12, 126, 3012, 9, 126, 1, 126, 1, 126, 5, 126, 3016, 8, 126, 10, 126, 12, 126, 3019, 9, 126, 1, 126, 1, 126, 5, 126, 3023, 8, 126, 10, 126, 12, 126, 3026, 9, 126, 3, 126, 3028, 8, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 5, 127, 3035, 8, 127, 10, 127, 12, 127, 3038, 9, 127, 1, 127, 3, 127, 3041, 8, 127, 1, 127, 5, 127, 3044, 8, 127, 10, 127, 12, 127, 3047, 9, 127, 1, 127, 1, 127, 5, 127, 3051, 8, 127, 10, 127, 12, 127, 3054, 9, 127, 1, 127, 1, 127, 5, 127, 3058, 8, 127, 10, 127, 12, 127, 3061, 9, 127, 5, 127, 3063, 8, 127, 10, 127, 12, 127, 3066, 9, 127, 1, 127, 5, 127, 3069, 8, 127, 10, 127, 12, 127, 3072, 9, 127, 1, 127, 1, 127, 1, 128, 1, 128, 5, 128, 3078, 8, 128, 10, 128, 12, 128, 3081, 9, 128, 1, 128, 1, 128, 5, 128, 3085, 8, 128, 10, 128, 12, 128, 3088, 9, 128, 1, 128, 5, 128, 3091, 8, 128, 10, 128, 12, 128, 3094, 9, 128, 1, 128, 5, 128, 3097, 8, 128, 10, 128, 12, 128, 3100, 9, 128, 1, 128, 3, 128, 3103, 8, 128, 1, 128, 5, 128, 3106, 8, 128, 10, 128, 12, 128, 3109, 9, 128, 1, 128, 1, 128, 5, 128, 3113, 8, 128, 10, 128, 12, 128, 3116, 9, 128, 1, 128, 1, 128, 3, 128, 3120, 8, 128, 1, 128, 1, 128, 5, 128, 3124, 8, 128, 10, 128, 12, 128, 3127, 9, 128, 1, 128, 1, 128, 5, 128, 3131, 8, 128, 10, 128, 12, 128, 3134, 9, 128, 1, 128, 1, 128, 3, 128, 3138, 8, 128, 3, 128, 3140, 8, 128, 1, 129, 1, 129, 1, 129, 3, 129, 3145, 8, 129, 1, 130, 1, 130, 5, 130, 3149, 8, 130, 10, 130, 12, 130, 3152, 9, 130, 1, 130, 1, 130, 1, 131, 1, 131, 5, 131, 3158, 8, 131, 10, 131, 12, 131, 3161, 9, 131, 1, 131, 1, 131, 1, 132, 1, 132, 5, 132, 3167, 8, 132, 10, 132, 12, 132, 3170, 9, 132, 1, 132, 1, 132, 5, 132, 3174, 8, 132, 10, 132, 12, 132, 3177, 9, 132, 1, 132, 4, 132, 3180, 8, 132, 11, 132, 12, 132, 3181, 1, 132, 5, 132, 3185, 8, 132, 10, 132, 12, 132, 3188, 9, 132, 1, 132, 3, 132, 3191, 8, 132, 1, 132, 5, 132, 3194, 8, 132, 10, 132, 12, 132, 3197, 9, 132, 1, 132, 3, 132, 3200, 8, 132, 1, 133, 1, 133, 5, 133, 3204, 8, 133, 10, 133, 12, 133, 3207, 9, 133, 1, 133, 1, 133, 5, 133, 3211, 8, 133, 10, 133, 12, 133, 3214, 9, 133, 1, 133, 1, 133, 1, 133, 1, 133, 5, 133, 3220, 8, 133, 10, 133, 12, 133, 3223, 9, 133, 1, 133, 3, 133, 3226, 8, 133, 1, 133, 1, 133, 5, 133, 3230, 8, 133, 10, 133, 12, 133, 3233, 9, 133, 1, 133, 1, 133, 1, 134, 1, 134, 5, 134, 3239, 8, 134, 10, 134, 12, 134, 3242, 9, 134, 1, 134, 1, 134, 1, 135, 1, 135, 5, 135, 3248, 8, 135, 10, 135, 12, 135, 3251, 9, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3256, 8, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3262, 8, 135, 1, 136, 3, 136, 3265, 8, 136, 1, 136, 1, 136, 5, 136, 3269, 8, 136, 10, 136, 12, 136, 3272, 9, 136, 1, 136, 1, 136, 3, 136, 3276, 8, 136, 1, 137, 1, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 3299, 8, 145, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3305, 8, 146, 1, 147, 1, 147, 1, 148, 5, 148, 3310, 8, 148, 10, 148, 12, 148, 3313, 9, 148, 1, 148, 1, 148, 5, 148, 3317, 8, 148, 10, 148, 12, 148, 3320, 9, 148, 1, 148, 1, 148, 3, 148, 3324, 8, 148, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 4, 150, 3331, 8, 150, 11, 150, 12, 150, 3332, 1, 151, 1, 151, 4, 151, 3337, 8, 151, 11, 151, 12, 151, 3338, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3349, 8, 152, 1, 152, 5, 152, 3352, 8, 152, 10, 152, 12, 152, 3355, 9, 152, 1, 153, 4, 153, 3358, 8, 153, 11, 153, 12, 153, 3359, 1, 154, 1, 154, 1, 154, 5, 154, 3365, 8, 154, 10, 154, 12, 154, 3368, 9, 154, 3, 154, 3370, 8, 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 4, 159, 3381, 8, 159, 11, 159, 12, 159, 3382, 1, 160, 1, 160, 5, 160, 3387, 8, 160, 10, 160, 12, 160, 3390, 9, 160, 1, 160, 1, 160, 5, 160, 3394, 8, 160, 10, 160, 12, 160, 3397, 9, 160, 1, 160, 3, 160, 3400, 8, 160, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 1, 167, 3, 167, 3416, 8, 167, 1, 167, 5, 167, 3419, 8, 167, 10, 167, 12, 167, 3422, 9, 167, 1, 168, 1, 168, 5, 168, 3426, 8, 168, 10, 168, 12, 168, 3429, 9, 168, 1, 168, 1, 168, 3, 168, 3433, 8, 168, 1, 168, 1, 168, 1, 169, 1, 169, 5, 169, 3439, 8, 169, 10, 169, 12, 169, 3442, 9, 169, 1, 169, 1, 169, 3, 169, 3446, 8, 169, 1, 169, 1, 169, 4, 169, 3450, 8, 169, 11, 169, 12, 169, 3451, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 5, 170, 3459, 8, 170, 10, 170, 12, 170, 3462, 9, 170, 1, 170, 1, 170, 1, 171, 1, 171, 3, 171, 3468, 8, 171, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3474, 8, 173, 10, 173, 12, 173, 3477, 9, 173, 1, 173, 1, 173, 5, 173, 3481, 8, 173, 10, 173, 12, 173, 3484, 9, 173, 1, 173, 0, 0, 174, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 0, 30, 2, 0, 40, 40, 42, 42, 1, 0, 77, 78, 1, 0, 84, 85, 1, 0, 44, 45, 1, 0, 40, 41, 2, 0, 5, 5, 27, 27, 2, 0, 136, 136, 139, 146, 1, 0, 160, 162, 1, 0, 165, 167, 2, 0, 60, 60, 84, 84, 2, 0, 57, 57, 98, 98, 1, 0, 29, 33, 2, 0, 50, 51, 53, 54, 1, 0, 46, 49, 2, 0, 103, 103, 105, 105, 2, 0, 102, 102, 104, 104, 1, 0, 18, 19, 1, 0, 15, 17, 2, 0, 52, 52, 101, 101, 1, 0, 24, 25, 1, 0, 112, 117, 2, 0, 124, 124, 129, 129, 1, 0, 108, 111, 2, 0, 103, 103, 106, 106, 1, 0, 118, 123, 1, 0, 125, 127, 1, 0, 130, 132, 1, 0, 134, 135, 1, 0, 63, 70, 7, 0, 62, 70, 72, 72, 80, 83, 87, 87, 92, 93, 106, 135, 147, 147, 3904, 0, 349, 1, 0, 0, 0, 2, 374, 1, 0, 0, 0, 4, 400, 1, 0, 0, 0, 6, 406, 1, 0, 0, 0, 8, 443, 1, 0, 0, 0, 10, 448, 1, 0, 0, 0, 12, 451, 1, 0, 0, 0, 14, 461, 1, 0, 0, 0, 16, 464, 1, 0, 0, 0, 18, 469, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 511, 1, 0, 0, 0, 24, 602, 1, 0, 0, 0, 26, 606, 1, 0, 0, 0, 28, 622, 1, 0, 0, 0, 30, 669, 1, 0, 0, 0, 32, 705, 1, 0, 0, 0, 34, 737, 1, 0, 0, 0, 36, 739, 1, 0, 0, 0, 38, 745, 1, 0, 0, 0, 40, 758, 1, 0, 0, 0, 42, 775, 1, 0, 0, 0, 44, 820, 1, 0, 0, 0, 46, 845, 1, 0, 0, 0, 48, 875, 1, 0, 0, 0, 50, 900, 1, 0, 0, 0, 52, 907, 1, 0, 0, 0, 54, 909, 1, 0, 0, 0, 56, 919, 1, 0, 0, 0, 58, 963, 1, 0, 0, 0, 60, 1010, 1, 0, 0, 0, 62, 1030, 1, 0, 0, 0, 64, 1116, 1, 0, 0, 0, 66, 1121, 1, 0, 0, 0, 68, 1147, 1, 0, 0, 0, 70, 1192, 1, 0, 0, 0, 72, 1305, 1, 0, 0, 0, 74, 1315, 1, 0, 0, 0, 76, 1358, 1, 0, 0, 0, 78, 1417, 1, 0, 0, 0, 80, 1464, 1, 0, 0, 0, 82, 1483, 1, 0, 0, 0, 84, 1500, 1, 0, 0, 0, 86, 1517, 1, 0, 0, 0, 88, 1553, 1, 0, 0, 0, 90, 1588, 1, 0, 0, 0, 92, 1597, 1, 0, 0, 0, 94, 1631, 1, 0, 0, 0, 96, 1667, 1, 0, 0, 0, 98, 1689, 1, 0, 0, 0, 100, 1700, 1, 0, 0, 0, 102, 1704, 1, 0, 0, 0, 104, 1717, 1, 0, 0, 0, 106, 1719, 1, 0, 0, 0, 108, 1739, 1, 0, 0, 0, 110, 1754, 1, 0, 0, 0, 112, 1757, 1, 0, 0, 0, 114, 1769, 1, 0, 0, 0, 116, 1785, 1, 0, 0, 0, 118, 1803, 1, 0, 0, 0, 120, 1853, 1, 0, 0, 0, 122, 1870, 1, 0, 0, 0, 124, 1877, 1, 0, 0, 0, 126, 1897, 1, 0, 0, 0, 128, 1932, 1, 0, 0, 0, 130, 1941, 1, 0, 0, 0, 132, 1950, 1, 0, 0, 0, 134, 1960, 1, 0, 0, 0, 136, 1962, 1, 0, 0, 0, 138, 1981, 1, 0, 0, 0, 140, 1983, 1, 0, 0, 0, 142, 2013, 1, 0, 0, 0, 144, 2033, 1, 0, 0, 0, 146, 2066, 1, 0, 0, 0, 148, 2076, 1, 0, 0, 0, 150, 2084, 1, 0, 0, 0, 152, 2088, 1, 0, 0, 0, 154, 2090, 1, 0, 0, 0, 156, 2110, 1, 0, 0, 0, 158, 2130, 1, 0, 0, 0, 160, 2145, 1, 0, 0, 0, 162, 2160, 1, 0, 0, 0, 164, 2167, 1, 0, 0, 0, 166, 2191, 1, 0, 0, 0, 168, 2212, 1, 0, 0, 0, 170, 2215, 1, 0, 0, 0, 172, 2230, 1, 0, 0, 0, 174, 2244, 1, 0, 0, 0, 176, 2259, 1, 0, 0, 0, 178, 2274, 1, 0, 0, 0, 180, 2298, 1, 0, 0, 0, 182, 2312, 1, 0, 0, 0, 184, 2314, 1, 0, 0, 0, 186, 2326, 1, 0, 0, 0, 188, 2333, 1, 0, 0, 0, 190, 2335, 1, 0, 0, 0, 192, 2353, 1, 0, 0, 0, 194, 2355, 1, 0, 0, 0, 196, 2374, 1, 0, 0, 0, 198, 2376, 1, 0, 0, 0, 200, 2420, 1, 0, 0, 0, 202, 2433, 1, 0, 0, 0, 204, 2445, 1, 0, 0, 0, 206, 2459, 1, 0, 0, 0, 208, 2503, 1, 0, 0, 0, 210, 2550, 1, 0, 0, 0, 212, 2599, 1, 0, 0, 0, 214, 2601, 1, 0, 0, 0, 216, 2617, 1, 0, 0, 0, 218, 2663, 1, 0, 0, 0, 220, 2667, 1, 0, 0, 0, 222, 2669, 1, 0, 0, 0, 224, 2679, 1, 0, 0, 0, 226, 2690, 1, 0, 0, 0, 228, 2692, 1, 0, 0, 0, 230, 2708, 1, 0, 0, 0, 232, 2710, 1, 0, 0, 0, 234, 2726, 1, 0, 0, 0, 236, 2760, 1, 0, 0, 0, 238, 2807, 1, 0, 0, 0, 240, 2809, 1, 0, 0, 0, 242, 2870, 1, 0, 0, 0, 244, 2872, 1, 0, 0, 0, 246, 2904, 1, 0, 0, 0, 248, 2930, 1, 0, 0, 0, 250, 2932, 1, 0, 0, 0, 252, 2993, 1, 0, 0, 0, 254, 3032, 1, 0, 0, 0, 256, 3139, 1, 0, 0, 0, 258, 3144, 1, 0, 0, 0, 260, 3146, 1, 0, 0, 0, 262, 3155, 1, 0, 0, 0, 264, 3164, 1, 0, 0, 0, 266, 3201, 1, 0, 0, 0, 268, 3236, 1, 0, 0, 0, 270, 3261, 1, 0, 0, 0, 272, 3264, 1, 0, 0, 0, 274, 3277, 1, 0, 0, 0, 276, 3279, 1, 0, 0, 0, 278, 3281, 1, 0, 0, 0, 280, 3283, 1, 0, 0, 0, 282, 3285, 1, 0, 0, 0, 284, 3287, 1, 0, 0, 0, 286, 3289, 1, 0, 0, 0, 288, 3291, 1, 0, 0, 0, 290, 3298, 1, 0, 0, 0, 292, 3304, 1, 0, 0, 0, 294, 3306, 1, 0, 0, 0, 296, 3323, 1, 0, 0, 0, 298, 3325, 1, 0, 0, 0, 300, 3330, 1, 0, 0, 0, 302, 3336, 1, 0, 0, 0, 304, 3348, 1, 0, 0, 0, 306, 3357, 1, 0, 0, 0, 308, 3369, 1, 0, 0, 0, 310, 3371, 1, 0, 0, 0, 312, 3373, 1, 0, 0, 0, 314, 3375, 1, 0, 0, 0, 316, 3377, 1, 0, 0, 0, 318, 3380, 1, 0, 0, 0, 320, 3399, 1, 0, 0, 0, 322, 3401, 1, 0, 0, 0, 324, 3403, 1, 0, 0, 0, 326, 3405, 1, 0, 0, 0, 328, 3407, 1, 0, 0, 0, 330, 3409, 1, 0, 0, 0, 332, 3411, 1, 0, 0, 0, 334, 3415, 1, 0, 0, 0, 336, 3432, 1, 0, 0, 0, 338, 3445, 1, 0, 0, 0, 340, 3455, 1, 0, 0, 0, 342, 3467, 1, 0, 0, 0, 344, 3469, 1, 0, 0, 0, 346, 3471, 1, 0, 0, 0, 348, 350, 3, 4, 2, 0, 349, 348, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 354, 1, 0, 0, 0, 351, 353, 5, 5, 0, 0, 352, 351, 1, 0, 0, 0, 353, 356, 1, 0, 0, 0, 354, 352, 1, 0, 0, 0, 354, 355, 1, 0, 0, 0, 355, 360, 1, 0, 0, 0, 356, 354, 1, 0, 0, 0, 357, 359, 3, 6, 3, 0, 358, 357, 1, 0, 0, 0, 359, 362, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 363, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 363, 364, 3, 8, 4, 0, 364, 368, 3, 10, 5, 0, 365, 367, 3, 16, 8, 0, 366, 365, 1, 0, 0, 0, 367, 370, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 371, 1, 0, 0, 0, 370, 368, 1, 0, 0, 0, 371, 372, 5, 0, 0, 1, 372, 1, 1, 0, 0, 0, 373, 375, 3, 4, 2, 0, 374, 373, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 379, 1, 0, 0, 0, 376, 378, 5, 5, 0, 0, 377, 376, 1, 0, 0, 0, 378, 381, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 385, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 382, 384, 3, 6, 3, 0, 383, 382, 1, 0, 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 388, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 389, 3, 8, 4, 0, 389, 395, 3, 10, 5, 0, 390, 391, 3, 130, 65, 0, 391, 392, 3, 148, 74, 0, 392, 394, 1, 0, 0, 0, 393, 390, 1, 0, 0, 0, 394, 397, 1, 0, 0, 0, 395, 393, 1, 0, 0, 0, 395, 396, 1, 0, 0, 0, 396, 398, 1, 0, 0, 0, 397, 395, 1, 0, 0, 0, 398, 399, 5, 0, 0, 1, 399, 3, 1, 0, 0, 0, 400, 402, 5, 1, 0, 0, 401, 403, 5, 5, 0, 0, 402, 401, 1, 0, 0, 0, 403, 404, 1, 0, 0, 0, 404, 402, 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 5, 1, 0, 0, 0, 406, 407, 7, 0, 0, 0, 407, 411, 5, 62, 0, 0, 408, 410, 5, 5, 0, 0, 409, 408, 1, 0, 0, 0, 410, 413, 1, 0, 0, 0, 411, 409, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 414, 1, 0, 0, 0, 413, 411, 1, 0, 0, 0, 414, 418, 5, 26, 0, 0, 415, 417, 5, 5, 0, 0, 416, 415, 1, 0, 0, 0, 417, 420, 1, 0, 0, 0, 418, 416, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 430, 1, 0, 0, 0, 420, 418, 1, 0, 0, 0, 421, 423, 5, 11, 0, 0, 422, 424, 3, 342, 171, 0, 423, 422, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 423, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 428, 5, 12, 0, 0, 428, 431, 1, 0, 0, 0, 429, 431, 3, 342, 171, 0, 430, 421, 1, 0, 0, 0, 430, 429, 1, 0, 0, 0, 431, 435, 1, 0, 0, 0, 432, 434, 5, 5, 0, 0, 433, 432, 1, 0, 0, 0, 434, 437, 1, 0, 0, 0, 435, 433, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 7, 1, 0, 0, 0, 437, 435, 1, 0, 0, 0, 438, 439, 5, 71, 0, 0, 439, 441, 3, 346, 173, 0, 440, 442, 3, 148, 74, 0, 441, 440, 1, 0, 0, 0, 441, 442, 1, 0, 0, 0, 442, 444, 1, 0, 0, 0, 443, 438, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 9, 1, 0, 0, 0, 445, 447, 3, 12, 6, 0, 446, 445, 1, 0, 0, 0, 447, 450, 1, 0, 0, 0, 448, 446, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 11, 1, 0, 0, 0, 450, 448, 1, 0, 0, 0, 451, 452, 5, 72, 0, 0, 452, 456, 3, 346, 173, 0, 453, 454, 5, 7, 0, 0, 454, 457, 5, 15, 0, 0, 455, 457, 3, 14, 7, 0, 456, 453, 1, 0, 0, 0, 456, 455, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 459, 1, 0, 0, 0, 458, 460, 3, 148, 74, 0, 459, 458, 1, 0, 0, 0, 459, 460, 1, 0, 0, 0, 460, 13, 1, 0, 0, 0, 461, 462, 5, 101, 0, 0, 462, 463, 3, 344, 172, 0, 463, 15, 1, 0, 0, 0, 464, 466, 3, 20, 10, 0, 465, 467, 3, 150, 75, 0, 466, 465, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 17, 1, 0, 0, 0, 468, 470, 3, 300, 150, 0, 469, 468, 1, 0, 0, 0, 469, 470, 1, 0, 0, 0, 470, 471, 1, 0, 0, 0, 471, 475, 5, 79, 0, 0, 472, 474, 5, 5, 0, 0, 473, 472, 1, 0, 0, 0, 474, 477, 1, 0, 0, 0, 475, 473, 1, 0, 0, 0, 475, 476, 1, 0, 0, 0, 476, 478, 1, 0, 0, 0, 477, 475, 1, 0, 0, 0, 478, 486, 3, 344, 172, 0, 479, 481, 5, 5, 0, 0, 480, 479, 1, 0, 0, 0, 481, 484, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 482, 483, 1, 0, 0, 0, 483, 485, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 485, 487, 3, 42, 21, 0, 486, 482, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 491, 1, 0, 0, 0, 488, 490, 5, 5, 0, 0, 489, 488, 1, 0, 0, 0, 490, 493, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 494, 1, 0, 0, 0, 493, 491, 1, 0, 0, 0, 494, 498, 5, 28, 0, 0, 495, 497, 5, 5, 0, 0, 496, 495, 1, 0, 0, 0, 497, 500, 1, 0, 0, 0, 498, 496, 1, 0, 0, 0, 498, 499, 1, 0, 0, 0, 499, 501, 1, 0, 0, 0, 500, 498, 1, 0, 0, 0, 501, 502, 3, 98, 49, 0, 502, 19, 1, 0, 0, 0, 503, 509, 3, 22, 11, 0, 504, 509, 3, 86, 43, 0, 505, 509, 3, 62, 31, 0, 506, 509, 3, 70, 35, 0, 507, 509, 3, 18, 9, 0, 508, 503, 1, 0, 0, 0, 508, 504, 1, 0, 0, 0, 508, 505, 1, 0, 0, 0, 508, 506, 1, 0, 0, 0, 508, 507, 1, 0, 0, 0, 509, 21, 1, 0, 0, 0, 510, 512, 3, 300, 150, 0, 511, 510, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 524, 1, 0, 0, 0, 513, 525, 5, 73, 0, 0, 514, 518, 5, 75, 0, 0, 515, 517, 5, 5, 0, 0, 516, 515, 1, 0, 0, 0, 517, 520, 1, 0, 0, 0, 518, 516, 1, 0, 0, 0, 518, 519, 1, 0, 0, 0, 519, 522, 1, 0, 0, 0, 520, 518, 1, 0, 0, 0, 521, 514, 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 523, 1, 0, 0, 0, 523, 525, 5, 74, 0, 0, 524, 513, 1, 0, 0, 0, 524, 521, 1, 0, 0, 0, 525, 529, 1, 0, 0, 0, 526, 528, 5, 5, 0, 0, 527, 526, 1, 0, 0, 0, 528, 531, 1, 0, 0, 0, 529, 527, 1, 0, 0, 0, 529, 530, 1, 0, 0, 0, 530, 532, 1, 0, 0, 0, 531, 529, 1, 0, 0, 0, 532, 540, 3, 344, 172, 0, 533, 535, 5, 5, 0, 0, 534, 533, 1, 0, 0, 0, 535, 538, 1, 0, 0, 0, 536, 534, 1, 0, 0, 0, 536, 537, 1, 0, 0, 0, 537, 539, 1, 0, 0, 0, 538, 536, 1, 0, 0, 0, 539, 541, 3, 42, 21, 0, 540, 536, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 549, 1, 0, 0, 0, 542, 544, 5, 5, 0, 0, 543, 542, 1, 0, 0, 0, 544, 547, 1, 0, 0, 0, 545, 543, 1, 0, 0, 0, 545, 546, 1, 0, 0, 0, 546, 548, 1, 0, 0, 0, 547, 545, 1, 0, 0, 0, 548, 550, 3, 24, 12, 0, 549, 545, 1, 0, 0, 0, 549, 550, 1, 0, 0, 0, 550, 565, 1, 0, 0, 0, 551, 553, 5, 5, 0, 0, 552, 551, 1, 0, 0, 0, 553, 556, 1, 0, 0, 0, 554, 552, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 557, 1, 0, 0, 0, 556, 554, 1, 0, 0, 0, 557, 561, 5, 26, 0, 0, 558, 560, 5, 5, 0, 0, 559, 558, 1, 0, 0, 0, 560, 563, 1, 0, 0, 0, 561, 559, 1, 0, 0, 0, 561, 562, 1, 0, 0, 0, 562, 564, 1, 0, 0, 0, 563, 561, 1, 0, 0, 0, 564, 566, 3, 32, 16, 0, 565, 554, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, 566, 574, 1, 0, 0, 0, 567, 569, 5, 5, 0, 0, 568, 567, 1, 0, 0, 0, 569, 572, 1, 0, 0, 0, 570, 568, 1, 0, 0, 0, 570, 571, 1, 0, 0, 0, 571, 573, 1, 0, 0, 0, 572, 570, 1, 0, 0, 0, 573, 575, 3, 46, 23, 0, 574, 570, 1, 0, 0, 0, 574, 575, 1, 0, 0, 0, 575, 590, 1, 0, 0, 0, 576, 578, 5, 5, 0, 0, 577, 576, 1, 0, 0, 0, 578, 581, 1, 0, 0, 0, 579, 577, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580, 582, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 591, 3, 26, 13, 0, 583, 585, 5, 5, 0, 0, 584, 583, 1, 0, 0, 0, 585, 588, 1, 0, 0, 0, 586, 584, 1, 0, 0, 0, 586, 587, 1, 0, 0, 0, 587, 589, 1, 0, 0, 0, 588, 586, 1, 0, 0, 0, 589, 591, 3, 92, 46, 0, 590, 579, 1, 0, 0, 0, 590, 586, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 23, 1, 0, 0, 0, 592, 594, 3, 300, 150, 0, 593, 592, 1, 0, 0, 0, 593, 594, 1, 0, 0, 0, 594, 595, 1, 0, 0, 0, 595, 599, 5, 80, 0, 0, 596, 598, 5, 5, 0, 0, 597, 596, 1, 0, 0, 0, 598, 601, 1, 0, 0, 0, 599, 597, 1, 0, 0, 0, 599, 600, 1, 0, 0, 0, 600, 603, 1, 0, 0, 0, 601, 599, 1, 0, 0, 0, 602, 593, 1, 0, 0, 0, 602, 603, 1, 0, 0, 0, 603, 604, 1, 0, 0, 0, 604, 605, 3, 28, 14, 0, 605, 25, 1, 0, 0, 0, 606, 610, 5, 13, 0, 0, 607, 609, 5, 5, 0, 0, 608, 607, 1, 0, 0, 0, 609, 612, 1, 0, 0, 0, 610, 608, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 613, 1, 0, 0, 0, 612, 610, 1, 0, 0, 0, 613, 617, 3, 50, 25, 0, 614, 616, 5, 5, 0, 0, 615, 614, 1, 0, 0, 0, 616, 619, 1, 0, 0, 0, 617, 615, 1, 0, 0, 0, 617, 618, 1, 0, 0, 0, 618, 620, 1, 0, 0, 0, 619, 617, 1, 0, 0, 0, 620, 621, 5, 14, 0, 0, 621, 27, 1, 0, 0, 0, 622, 626, 5, 9, 0, 0, 623, 625, 5, 5, 0, 0, 624, 623, 1, 0, 0, 0, 625, 628, 1, 0, 0, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 658, 1, 0, 0, 0, 628, 626, 1, 0, 0, 0, 629, 646, 3, 30, 15, 0, 630, 632, 5, 5, 0, 0, 631, 630, 1, 0, 0, 0, 632, 635, 1, 0, 0, 0, 633, 631, 1, 0, 0, 0, 633, 634, 1, 0, 0, 0, 634, 636, 1, 0, 0, 0, 635, 633, 1, 0, 0, 0, 636, 640, 5, 8, 0, 0, 637, 639, 5, 5, 0, 0, 638, 637, 1, 0, 0, 0, 639, 642, 1, 0, 0, 0, 640, 638, 1, 0, 0, 0, 640, 641, 1, 0, 0, 0, 641, 643, 1, 0, 0, 0, 642, 640, 1, 0, 0, 0, 643, 645, 3, 30, 15, 0, 644, 633, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 656, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, 651, 5, 5, 0, 0, 650, 649, 1, 0, 0, 0, 651, 654, 1, 0, 0, 0, 652, 650, 1, 0, 0, 0, 652, 653, 1, 0, 0, 0, 653, 655, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 655, 657, 5, 8, 0, 0, 656, 652, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 659, 1, 0, 0, 0, 658, 629, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 663, 1, 0, 0, 0, 660, 662, 5, 5, 0, 0, 661, 660, 1, 0, 0, 0, 662, 665, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 666, 1, 0, 0, 0, 665, 663, 1, 0, 0, 0, 666, 667, 5, 10, 0, 0, 667, 29, 1, 0, 0, 0, 668, 670, 3, 300, 150, 0, 669, 668, 1, 0, 0, 0, 669, 670, 1, 0, 0, 0, 670, 672, 1, 0, 0, 0, 671, 673, 7, 1, 0, 0, 672, 671, 1, 0, 0, 0, 672, 673, 1, 0, 0, 0, 673, 677, 1, 0, 0, 0, 674, 676, 5, 5, 0, 0, 675, 674, 1, 0, 0, 0, 676, 679, 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 677, 678, 1, 0, 0, 0, 678, 680, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 680, 681, 3, 344, 172, 0, 681, 685, 5, 26, 0, 0, 682, 684, 5, 5, 0, 0, 683, 682, 1, 0, 0, 0, 684, 687, 1, 0, 0, 0, 685, 683, 1, 0, 0, 0, 685, 686, 1, 0, 0, 0, 686, 688, 1, 0, 0, 0, 687, 685, 1, 0, 0, 0, 688, 703, 3, 98, 49, 0, 689, 691, 5, 5, 0, 0, 690, 689, 1, 0, 0, 0, 691, 694, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0, 693, 695, 1, 0, 0, 0, 694, 692, 1, 0, 0, 0, 695, 699, 5, 28, 0, 0, 696, 698, 5, 5, 0, 0, 697, 696, 1, 0, 0, 0, 698, 701, 1, 0, 0, 0, 699, 697, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 702, 1, 0, 0, 0, 701, 699, 1, 0, 0, 0, 702, 704, 3, 152, 76, 0, 703, 692, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 31, 1, 0, 0, 0, 705, 722, 3, 38, 19, 0, 706, 708, 5, 5, 0, 0, 707, 706, 1, 0, 0, 0, 708, 711, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 712, 1, 0, 0, 0, 711, 709, 1, 0, 0, 0, 712, 716, 5, 8, 0, 0, 713, 715, 5, 5, 0, 0, 714, 713, 1, 0, 0, 0, 715, 718, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 719, 1, 0, 0, 0, 718, 716, 1, 0, 0, 0, 719, 721, 3, 38, 19, 0, 720, 709, 1, 0, 0, 0, 721, 724, 1, 0, 0, 0, 722, 720, 1, 0, 0, 0, 722, 723, 1, 0, 0, 0, 723, 33, 1, 0, 0, 0, 724, 722, 1, 0, 0, 0, 725, 738, 3, 36, 18, 0, 726, 738, 3, 40, 20, 0, 727, 738, 3, 106, 53, 0, 728, 738, 3, 116, 58, 0, 729, 733, 5, 123, 0, 0, 730, 732, 5, 5, 0, 0, 731, 730, 1, 0, 0, 0, 732, 735, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, 736, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 736, 738, 3, 116, 58, 0, 737, 725, 1, 0, 0, 0, 737, 726, 1, 0, 0, 0, 737, 727, 1, 0, 0, 0, 737, 728, 1, 0, 0, 0, 737, 729, 1, 0, 0, 0, 738, 35, 1, 0, 0, 0, 739, 740, 3, 106, 53, 0, 740, 741, 3, 208, 104, 0, 741, 37, 1, 0, 0, 0, 742, 744, 3, 334, 167, 0, 743, 742, 1, 0, 0, 0, 744, 747, 1, 0, 0, 0, 745, 743, 1, 0, 0, 0, 745, 746, 1, 0, 0, 0, 746, 751, 1, 0, 0, 0, 747, 745, 1, 0, 0, 0, 748, 750, 5, 5, 0, 0, 749, 748, 1, 0, 0, 0, 750, 753, 1, 0, 0, 0, 751, 749, 1, 0, 0, 0, 751, 752, 1, 0, 0, 0, 752, 754, 1, 0, 0, 0, 753, 751, 1, 0, 0, 0, 754, 755, 3, 34, 17, 0, 755, 39, 1, 0, 0, 0, 756, 759, 3, 106, 53, 0, 757, 759, 3, 116, 58, 0, 758, 756, 1, 0, 0, 0, 758, 757, 1, 0, 0, 0, 759, 763, 1, 0, 0, 0, 760, 762, 5, 5, 0, 0, 761, 760, 1, 0, 0, 0, 762, 765, 1, 0, 0, 0, 763, 761, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 766, 1, 0, 0, 0, 765, 763, 1, 0, 0, 0, 766, 770, 5, 81, 0, 0, 767, 769, 5, 5, 0, 0, 768, 767, 1, 0, 0, 0, 769, 772, 1, 0, 0, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 773, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 774, 3, 152, 76, 0, 774, 41, 1, 0, 0, 0, 775, 779, 5, 46, 0, 0, 776, 778, 5, 5, 0, 0, 777, 776, 1, 0, 0, 0, 778, 781, 1, 0, 0, 0, 779, 777, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 782, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 799, 3, 44, 22, 0, 783, 785, 5, 5, 0, 0, 784, 783, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 789, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789, 793, 5, 8, 0, 0, 790, 792, 5, 5, 0, 0, 791, 790, 1, 0, 0, 0, 792, 795, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 793, 794, 1, 0, 0, 0, 794, 796, 1, 0, 0, 0, 795, 793, 1, 0, 0, 0, 796, 798, 3, 44, 22, 0, 797, 786, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 809, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 804, 5, 5, 0, 0, 803, 802, 1, 0, 0, 0, 804, 807, 1, 0, 0, 0, 805, 803, 1, 0, 0, 0, 805, 806, 1, 0, 0, 0, 806, 808, 1, 0, 0, 0, 807, 805, 1, 0, 0, 0, 808, 810, 5, 8, 0, 0, 809, 805, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 814, 1, 0, 0, 0, 811, 813, 5, 5, 0, 0, 812, 811, 1, 0, 0, 0, 813, 816, 1, 0, 0, 0, 814, 812, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 817, 1, 0, 0, 0, 816, 814, 1, 0, 0, 0, 817, 818, 5, 47, 0, 0, 818, 43, 1, 0, 0, 0, 819, 821, 3, 318, 159, 0, 820, 819, 1, 0, 0, 0, 820, 821, 1, 0, 0, 0, 821, 825, 1, 0, 0, 0, 822, 824, 5, 5, 0, 0, 823, 822, 1, 0, 0, 0, 824, 827, 1, 0, 0, 0, 825, 823, 1, 0, 0, 0, 825, 826, 1, 0, 0, 0, 826, 828, 1, 0, 0, 0, 827, 825, 1, 0, 0, 0, 828, 843, 3, 344, 172, 0, 829, 831, 5, 5, 0, 0, 830, 829, 1, 0, 0, 0, 831, 834, 1, 0, 0, 0, 832, 830, 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 835, 1, 0, 0, 0, 834, 832, 1, 0, 0, 0, 835, 839, 5, 26, 0, 0, 836, 838, 5, 5, 0, 0, 837, 836, 1, 0, 0, 0, 838, 841, 1, 0, 0, 0, 839, 837, 1, 0, 0, 0, 839, 840, 1, 0, 0, 0, 840, 842, 1, 0, 0, 0, 841, 839, 1, 0, 0, 0, 842, 844, 3, 98, 49, 0, 843, 832, 1, 0, 0, 0, 843, 844, 1, 0, 0, 0, 844, 45, 1, 0, 0, 0, 845, 849, 5, 87, 0, 0, 846, 848, 5, 5, 0, 0, 847, 846, 1, 0, 0, 0, 848, 851, 1, 0, 0, 0, 849, 847, 1, 0, 0, 0, 849, 850, 1, 0, 0, 0, 850, 852, 1, 0, 0, 0, 851, 849, 1, 0, 0, 0, 852, 869, 3, 48, 24, 0, 853, 855, 5, 5, 0, 0, 854, 853, 1, 0, 0, 0, 855, 858, 1, 0, 0, 0, 856, 854, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 859, 1, 0, 0, 0, 858, 856, 1, 0, 0, 0, 859, 863, 5, 8, 0, 0, 860, 862, 5, 5, 0, 0, 861, 860, 1, 0, 0, 0, 862, 865, 1, 0, 0, 0, 863, 861, 1, 0, 0, 0, 863, 864, 1, 0, 0, 0, 864, 866, 1, 0, 0, 0, 865, 863, 1, 0, 0, 0, 866, 868, 3, 48, 24, 0, 867, 856, 1, 0, 0, 0, 868, 871, 1, 0, 0, 0, 869, 867, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 47, 1, 0, 0, 0, 871, 869, 1, 0, 0, 0, 872, 874, 3, 334, 167, 0, 873, 872, 1, 0, 0, 0, 874, 877, 1, 0, 0, 0, 875, 873, 1, 0, 0, 0, 875, 876, 1, 0, 0, 0, 876, 878, 1, 0, 0, 0, 877, 875, 1, 0, 0, 0, 878, 882, 3, 344, 172, 0, 879, 881, 5, 5, 0, 0, 880, 879, 1, 0, 0, 0, 881, 884, 1, 0, 0, 0, 882, 880, 1, 0, 0, 0, 882, 883, 1, 0, 0, 0, 883, 885, 1, 0, 0, 0, 884, 882, 1, 0, 0, 0, 885, 889, 5, 26, 0, 0, 886, 888, 5, 5, 0, 0, 887, 886, 1, 0, 0, 0, 888, 891, 1, 0, 0, 0, 889, 887, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 892, 1, 0, 0, 0, 891, 889, 1, 0, 0, 0, 892, 893, 3, 98, 49, 0, 893, 49, 1, 0, 0, 0, 894, 896, 3, 52, 26, 0, 895, 897, 3, 150, 75, 0, 896, 895, 1, 0, 0, 0, 896, 897, 1, 0, 0, 0, 897, 899, 1, 0, 0, 0, 898, 894, 1, 0, 0, 0, 899, 902, 1, 0, 0, 0, 900, 898, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 51, 1, 0, 0, 0, 902, 900, 1, 0, 0, 0, 903, 908, 3, 20, 10, 0, 904, 908, 3, 56, 28, 0, 905, 908, 3, 54, 27, 0, 906, 908, 3, 88, 44, 0, 907, 903, 1, 0, 0, 0, 907, 904, 1, 0, 0, 0, 907, 905, 1, 0, 0, 0, 907, 906, 1, 0, 0, 0, 908, 53, 1, 0, 0, 0, 909, 913, 5, 83, 0, 0, 910, 912, 5, 5, 0, 0, 911, 910, 1, 0, 0, 0, 912, 915, 1, 0, 0, 0, 913, 911, 1, 0, 0, 0, 913, 914, 1, 0, 0, 0, 914, 916, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 916, 917, 3, 136, 68, 0, 917, 55, 1, 0, 0, 0, 918, 920, 3, 300, 150, 0, 919, 918, 1, 0, 0, 0, 919, 920, 1, 0, 0, 0, 920, 921, 1, 0, 0, 0, 921, 925, 5, 82, 0, 0, 922, 924, 5, 5, 0, 0, 923, 922, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, 928, 1, 0, 0, 0, 927, 925, 1, 0, 0, 0, 928, 936, 5, 76, 0, 0, 929, 931, 5, 5, 0, 0, 930, 929, 1, 0, 0, 0, 931, 934, 1, 0, 0, 0, 932, 930, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 935, 1, 0, 0, 0, 934, 932, 1, 0, 0, 0, 935, 937, 3, 344, 172, 0, 936, 932, 1, 0, 0, 0, 936, 937, 1, 0, 0, 0, 937, 952, 1, 0, 0, 0, 938, 940, 5, 5, 0, 0, 939, 938, 1, 0, 0, 0, 940, 943, 1, 0, 0, 0, 941, 939, 1, 0, 0, 0, 941, 942, 1, 0, 0, 0, 942, 944, 1, 0, 0, 0, 943, 941, 1, 0, 0, 0, 944, 948, 5, 26, 0, 0, 945, 947, 5, 5, 0, 0, 946, 945, 1, 0, 0, 0, 947, 950, 1, 0, 0, 0, 948, 946, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 951, 1, 0, 0, 0, 950, 948, 1, 0, 0, 0, 951, 953, 3, 32, 16, 0, 952, 941, 1, 0, 0, 0, 952, 953, 1, 0, 0, 0, 953, 961, 1, 0, 0, 0, 954, 956, 5, 5, 0, 0, 955, 954, 1, 0, 0, 0, 956, 959, 1, 0, 0, 0, 957, 955, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 960, 1, 0, 0, 0, 959, 957, 1, 0, 0, 0, 960, 962, 3, 26, 13, 0, 961, 957, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 57, 1, 0, 0, 0, 963, 967, 5, 9, 0, 0, 964, 966, 5, 5, 0, 0, 965, 964, 1, 0, 0, 0, 966, 969, 1, 0, 0, 0, 967, 965, 1, 0, 0, 0, 967, 968, 1, 0, 0, 0, 968, 999, 1, 0, 0, 0, 969, 967, 1, 0, 0, 0, 970, 987, 3, 60, 30, 0, 971, 973, 5, 5, 0, 0, 972, 971, 1, 0, 0, 0, 973, 976, 1, 0, 0, 0, 974, 972, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 977, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 977, 981, 5, 8, 0, 0, 978, 980, 5, 5, 0, 0, 979, 978, 1, 0, 0, 0, 980, 983, 1, 0, 0, 0, 981, 979, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 984, 1, 0, 0, 0, 983, 981, 1, 0, 0, 0, 984, 986, 3, 60, 30, 0, 985, 974, 1, 0, 0, 0, 986, 989, 1, 0, 0, 0, 987, 985, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 997, 1, 0, 0, 0, 989, 987, 1, 0, 0, 0, 990, 992, 5, 5, 0, 0, 991, 990, 1, 0, 0, 0, 992, 995, 1, 0, 0, 0, 993, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 996, 1, 0, 0, 0, 995, 993, 1, 0, 0, 0, 996, 998, 5, 8, 0, 0, 997, 993, 1, 0, 0, 0, 997, 998, 1, 0, 0, 0, 998, 1000, 1, 0, 0, 0, 999, 970, 1, 0, 0, 0, 999, 1000, 1, 0, 0, 0, 1000, 1004, 1, 0, 0, 0, 1001, 1003, 5, 5, 0, 0, 1002, 1001, 1, 0, 0, 0, 1003, 1006, 1, 0, 0, 0, 1004, 1002, 1, 0, 0, 0, 1004, 1005, 1, 0, 0, 0, 1005, 1007, 1, 0, 0, 0, 1006, 1004, 1, 0, 0, 0, 1007, 1008, 5, 10, 0, 0, 1008, 59, 1, 0, 0, 0, 1009, 1011, 3, 302, 151, 0, 1010, 1009, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 1, 0, 0, 0, 1012, 1027, 3, 84, 42, 0, 1013, 1015, 5, 5, 0, 0, 1014, 1013, 1, 0, 0, 0, 1015, 1018, 1, 0, 0, 0, 1016, 1014, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 1023, 5, 28, 0, 0, 1020, 1022, 5, 5, 0, 0, 1021, 1020, 1, 0, 0, 0, 1022, 1025, 1, 0, 0, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1026, 1, 0, 0, 0, 1025, 1023, 1, 0, 0, 0, 1026, 1028, 3, 152, 76, 0, 1027, 1016, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 61, 1, 0, 0, 0, 1029, 1031, 3, 300, 150, 0, 1030, 1029, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 1040, 5, 75, 0, 0, 1033, 1035, 5, 5, 0, 0, 1034, 1033, 1, 0, 0, 0, 1035, 1038, 1, 0, 0, 0, 1036, 1034, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1039, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1039, 1041, 3, 42, 21, 0, 1040, 1036, 1, 0, 0, 0, 1040, 1041, 1, 0, 0, 0, 1041, 1057, 1, 0, 0, 0, 1042, 1044, 5, 5, 0, 0, 1043, 1042, 1, 0, 0, 0, 1044, 1047, 1, 0, 0, 0, 1045, 1043, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1048, 1, 0, 0, 0, 1047, 1045, 1, 0, 0, 0, 1048, 1052, 3, 122, 61, 0, 1049, 1051, 5, 5, 0, 0, 1050, 1049, 1, 0, 0, 0, 1051, 1054, 1, 0, 0, 0, 1052, 1050, 1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1052, 1, 0, 0, 0, 1055, 1056, 5, 7, 0, 0, 1056, 1058, 1, 0, 0, 0, 1057, 1045, 1, 0, 0, 0, 1057, 1058, 1, 0, 0, 0, 1058, 1062, 1, 0, 0, 0, 1059, 1061, 5, 5, 0, 0, 1060, 1059, 1, 0, 0, 0, 1061, 1064, 1, 0, 0, 0, 1062, 1060, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1065, 1, 0, 0, 0, 1064, 1062, 1, 0, 0, 0, 1065, 1069, 3, 344, 172, 0, 1066, 1068, 5, 5, 0, 0, 1067, 1066, 1, 0, 0, 0, 1068, 1071, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1069, 1, 0, 0, 0, 1072, 1087, 3, 58, 29, 0, 1073, 1075, 5, 5, 0, 0, 1074, 1073, 1, 0, 0, 0, 1075, 1078, 1, 0, 0, 0, 1076, 1074, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 1079, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1079, 1083, 5, 26, 0, 0, 1080, 1082, 5, 5, 0, 0, 1081, 1080, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1081, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1086, 1088, 3, 98, 49, 0, 1087, 1076, 1, 0, 0, 0, 1087, 1088, 1, 0, 0, 0, 1088, 1096, 1, 0, 0, 0, 1089, 1091, 5, 5, 0, 0, 1090, 1089, 1, 0, 0, 0, 1091, 1094, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1092, 1093, 1, 0, 0, 0, 1093, 1095, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1095, 1097, 3, 46, 23, 0, 1096, 1092, 1, 0, 0, 0, 1096, 1097, 1, 0, 0, 0, 1097, 1105, 1, 0, 0, 0, 1098, 1100, 5, 5, 0, 0, 1099, 1098, 1, 0, 0, 0, 1100, 1103, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1101, 1102, 1, 0, 0, 0, 1102, 1104, 1, 0, 0, 0, 1103, 1101, 1, 0, 0, 0, 1104, 1106, 3, 64, 32, 0, 1105, 1101, 1, 0, 0, 0, 1105, 1106, 1, 0, 0, 0, 1106, 63, 1, 0, 0, 0, 1107, 1117, 3, 136, 68, 0, 1108, 1112, 5, 28, 0, 0, 1109, 1111, 5, 5, 0, 0, 1110, 1109, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1117, 3, 152, 76, 0, 1116, 1107, 1, 0, 0, 0, 1116, 1108, 1, 0, 0, 0, 1117, 65, 1, 0, 0, 0, 1118, 1120, 3, 334, 167, 0, 1119, 1118, 1, 0, 0, 0, 1120, 1123, 1, 0, 0, 0, 1121, 1119, 1, 0, 0, 0, 1121, 1122, 1, 0, 0, 0, 1122, 1127, 1, 0, 0, 0, 1123, 1121, 1, 0, 0, 0, 1124, 1126, 5, 5, 0, 0, 1125, 1124, 1, 0, 0, 0, 1126, 1129, 1, 0, 0, 0, 1127, 1125, 1, 0, 0, 0, 1127, 1128, 1, 0, 0, 0, 1128, 1130, 1, 0, 0, 0, 1129, 1127, 1, 0, 0, 0, 1130, 1145, 3, 344, 172, 0, 1131, 1133, 5, 5, 0, 0, 1132, 1131, 1, 0, 0, 0, 1133, 1136, 1, 0, 0, 0, 1134, 1132, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1137, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1137, 1141, 5, 26, 0, 0, 1138, 1140, 5, 5, 0, 0, 1139, 1138, 1, 0, 0, 0, 1140, 1143, 1, 0, 0, 0, 1141, 1139, 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 1144, 1, 0, 0, 0, 1143, 1141, 1, 0, 0, 0, 1144, 1146, 3, 98, 49, 0, 1145, 1134, 1, 0, 0, 0, 1145, 1146, 1, 0, 0, 0, 1146, 67, 1, 0, 0, 0, 1147, 1151, 5, 9, 0, 0, 1148, 1150, 5, 5, 0, 0, 1149, 1148, 1, 0, 0, 0, 1150, 1153, 1, 0, 0, 0, 1151, 1149, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1154, 1, 0, 0, 0, 1153, 1151, 1, 0, 0, 0, 1154, 1171, 3, 66, 33, 0, 1155, 1157, 5, 5, 0, 0, 1156, 1155, 1, 0, 0, 0, 1157, 1160, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1161, 1, 0, 0, 0, 1160, 1158, 1, 0, 0, 0, 1161, 1165, 5, 8, 0, 0, 1162, 1164, 5, 5, 0, 0, 1163, 1162, 1, 0, 0, 0, 1164, 1167, 1, 0, 0, 0, 1165, 1163, 1, 0, 0, 0, 1165, 1166, 1, 0, 0, 0, 1166, 1168, 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1168, 1170, 3, 66, 33, 0, 1169, 1158, 1, 0, 0, 0, 1170, 1173, 1, 0, 0, 0, 1171, 1169, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1181, 1, 0, 0, 0, 1173, 1171, 1, 0, 0, 0, 1174, 1176, 5, 5, 0, 0, 1175, 1174, 1, 0, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 1180, 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1180, 1182, 5, 8, 0, 0, 1181, 1177, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1186, 1, 0, 0, 0, 1183, 1185, 5, 5, 0, 0, 1184, 1183, 1, 0, 0, 0, 1185, 1188, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, 1186, 1187, 1, 0, 0, 0, 1187, 1189, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, 1189, 1190, 5, 10, 0, 0, 1190, 69, 1, 0, 0, 0, 1191, 1193, 3, 300, 150, 0, 1192, 1191, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1202, 7, 1, 0, 0, 1195, 1197, 5, 5, 0, 0, 1196, 1195, 1, 0, 0, 0, 1197, 1200, 1, 0, 0, 0, 1198, 1196, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 1201, 1, 0, 0, 0, 1200, 1198, 1, 0, 0, 0, 1201, 1203, 3, 42, 21, 0, 1202, 1198, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 1219, 1, 0, 0, 0, 1204, 1206, 5, 5, 0, 0, 1205, 1204, 1, 0, 0, 0, 1206, 1209, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1210, 1, 0, 0, 0, 1209, 1207, 1, 0, 0, 0, 1210, 1214, 3, 122, 61, 0, 1211, 1213, 5, 5, 0, 0, 1212, 1211, 1, 0, 0, 0, 1213, 1216, 1, 0, 0, 0, 1214, 1212, 1, 0, 0, 0, 1214, 1215, 1, 0, 0, 0, 1215, 1217, 1, 0, 0, 0, 1216, 1214, 1, 0, 0, 0, 1217, 1218, 5, 7, 0, 0, 1218, 1220, 1, 0, 0, 0, 1219, 1207, 1, 0, 0, 0, 1219, 1220, 1, 0, 0, 0, 1220, 1224, 1, 0, 0, 0, 1221, 1223, 5, 5, 0, 0, 1222, 1221, 1, 0, 0, 0, 1223, 1226, 1, 0, 0, 0, 1224, 1222, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1229, 1, 0, 0, 0, 1226, 1224, 1, 0, 0, 0, 1227, 1230, 3, 68, 34, 0, 1228, 1230, 3, 66, 33, 0, 1229, 1227, 1, 0, 0, 0, 1229, 1228, 1, 0, 0, 0, 1230, 1238, 1, 0, 0, 0, 1231, 1233, 5, 5, 0, 0, 1232, 1231, 1, 0, 0, 0, 1233, 1236, 1, 0, 0, 0, 1234, 1232, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1237, 1, 0, 0, 0, 1236, 1234, 1, 0, 0, 0, 1237, 1239, 3, 46, 23, 0, 1238, 1234, 1, 0, 0, 0, 1238, 1239, 1, 0, 0, 0, 1239, 1257, 1, 0, 0, 0, 1240, 1242, 5, 5, 0, 0, 1241, 1240, 1, 0, 0, 0, 1242, 1245, 1, 0, 0, 0, 1243, 1241, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1255, 1, 0, 0, 0, 1245, 1243, 1, 0, 0, 0, 1246, 1250, 5, 28, 0, 0, 1247, 1249, 5, 5, 0, 0, 1248, 1247, 1, 0, 0, 0, 1249, 1252, 1, 0, 0, 0, 1250, 1248, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1253, 1, 0, 0, 0, 1252, 1250, 1, 0, 0, 0, 1253, 1256, 3, 152, 76, 0, 1254, 1256, 3, 72, 36, 0, 1255, 1246, 1, 0, 0, 0, 1255, 1254, 1, 0, 0, 0, 1256, 1258, 1, 0, 0, 0, 1257, 1243, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1265, 1, 0, 0, 0, 1259, 1261, 5, 5, 0, 0, 1260, 1259, 1, 0, 0, 0, 1261, 1262, 1, 0, 0, 0, 1262, 1260, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1266, 5, 27, 0, 0, 1265, 1260, 1, 0, 0, 0, 1265, 1266, 1, 0, 0, 0, 1266, 1270, 1, 0, 0, 0, 1267, 1269, 5, 5, 0, 0, 1268, 1267, 1, 0, 0, 0, 1269, 1272, 1, 0, 0, 0, 1270, 1268, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, 1303, 1, 0, 0, 0, 1272, 1270, 1, 0, 0, 0, 1273, 1275, 3, 74, 37, 0, 1274, 1273, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1286, 1, 0, 0, 0, 1276, 1278, 5, 5, 0, 0, 1277, 1276, 1, 0, 0, 0, 1278, 1281, 1, 0, 0, 0, 1279, 1277, 1, 0, 0, 0, 1279, 1280, 1, 0, 0, 0, 1280, 1283, 1, 0, 0, 0, 1281, 1279, 1, 0, 0, 0, 1282, 1284, 3, 148, 74, 0, 1283, 1282, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 3, 76, 38, 0, 1286, 1279, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 1304, 1, 0, 0, 0, 1288, 1290, 3, 76, 38, 0, 1289, 1288, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1301, 1, 0, 0, 0, 1291, 1293, 5, 5, 0, 0, 1292, 1291, 1, 0, 0, 0, 1293, 1296, 1, 0, 0, 0, 1294, 1292, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, 1298, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1297, 1299, 3, 148, 74, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1302, 3, 74, 37, 0, 1301, 1294, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1304, 1, 0, 0, 0, 1303, 1274, 1, 0, 0, 0, 1303, 1289, 1, 0, 0, 0, 1304, 71, 1, 0, 0, 0, 1305, 1309, 5, 81, 0, 0, 1306, 1308, 5, 5, 0, 0, 1307, 1306, 1, 0, 0, 0, 1308, 1311, 1, 0, 0, 0, 1309, 1307, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1312, 1, 0, 0, 0, 1311, 1309, 1, 0, 0, 0, 1312, 1313, 3, 152, 76, 0, 1313, 73, 1, 0, 0, 0, 1314, 1316, 3, 300, 150, 0, 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 1355, 5, 65, 0, 0, 1318, 1320, 5, 5, 0, 0, 1319, 1318, 1, 0, 0, 0, 1320, 1323, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1324, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1324, 1328, 5, 9, 0, 0, 1325, 1327, 5, 5, 0, 0, 1326, 1325, 1, 0, 0, 0, 1327, 1330, 1, 0, 0, 0, 1328, 1326, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1331, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1331, 1346, 5, 10, 0, 0, 1332, 1334, 5, 5, 0, 0, 1333, 1332, 1, 0, 0, 0, 1334, 1337, 1, 0, 0, 0, 1335, 1333, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 1338, 1, 0, 0, 0, 1337, 1335, 1, 0, 0, 0, 1338, 1342, 5, 26, 0, 0, 1339, 1341, 5, 5, 0, 0, 1340, 1339, 1, 0, 0, 0, 1341, 1344, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1345, 1, 0, 0, 0, 1344, 1342, 1, 0, 0, 0, 1345, 1347, 3, 98, 49, 0, 1346, 1335, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1351, 1, 0, 0, 0, 1348, 1350, 5, 5, 0, 0, 1349, 1348, 1, 0, 0, 0, 1350, 1353, 1, 0, 0, 0, 1351, 1349, 1, 0, 0, 0, 1351, 1352, 1, 0, 0, 0, 1352, 1354, 1, 0, 0, 0, 1353, 1351, 1, 0, 0, 0, 1354, 1356, 3, 64, 32, 0, 1355, 1321, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 75, 1, 0, 0, 0, 1357, 1359, 3, 300, 150, 0, 1358, 1357, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, 1359, 1360, 1, 0, 0, 0, 1360, 1415, 5, 66, 0, 0, 1361, 1363, 5, 5, 0, 0, 1362, 1361, 1, 0, 0, 0, 1363, 1366, 1, 0, 0, 0, 1364, 1362, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1367, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1371, 5, 9, 0, 0, 1368, 1370, 5, 5, 0, 0, 1369, 1368, 1, 0, 0, 0, 1370, 1373, 1, 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 1382, 3, 80, 40, 0, 1375, 1377, 5, 5, 0, 0, 1376, 1375, 1, 0, 0, 0, 1377, 1380, 1, 0, 0, 0, 1378, 1376, 1, 0, 0, 0, 1378, 1379, 1, 0, 0, 0, 1379, 1381, 1, 0, 0, 0, 1380, 1378, 1, 0, 0, 0, 1381, 1383, 5, 8, 0, 0, 1382, 1378, 1, 0, 0, 0, 1382, 1383, 1, 0, 0, 0, 1383, 1387, 1, 0, 0, 0, 1384, 1386, 5, 5, 0, 0, 1385, 1384, 1, 0, 0, 0, 1386, 1389, 1, 0, 0, 0, 1387, 1385, 1, 0, 0, 0, 1387, 1388, 1, 0, 0, 0, 1388, 1390, 1, 0, 0, 0, 1389, 1387, 1, 0, 0, 0, 1390, 1405, 5, 10, 0, 0, 1391, 1393, 5, 5, 0, 0, 1392, 1391, 1, 0, 0, 0, 1393, 1396, 1, 0, 0, 0, 1394, 1392, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, 0, 1395, 1397, 1, 0, 0, 0, 1396, 1394, 1, 0, 0, 0, 1397, 1401, 5, 26, 0, 0, 1398, 1400, 5, 5, 0, 0, 1399, 1398, 1, 0, 0, 0, 1400, 1403, 1, 0, 0, 0, 1401, 1399, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0, 1402, 1404, 1, 0, 0, 0, 1403, 1401, 1, 0, 0, 0, 1404, 1406, 3, 98, 49, 0, 1405, 1394, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1410, 1, 0, 0, 0, 1407, 1409, 5, 5, 0, 0, 1408, 1407, 1, 0, 0, 0, 1409, 1412, 1, 0, 0, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1411, 1, 0, 0, 0, 1411, 1413, 1, 0, 0, 0, 1412, 1410, 1, 0, 0, 0, 1413, 1414, 3, 64, 32, 0, 1414, 1416, 1, 0, 0, 0, 1415, 1364, 1, 0, 0, 0, 1415, 1416, 1, 0, 0, 0, 1416, 77, 1, 0, 0, 0, 1417, 1421, 5, 9, 0, 0, 1418, 1420, 5, 5, 0, 0, 1419, 1418, 1, 0, 0, 0, 1420, 1423, 1, 0, 0, 0, 1421, 1419, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 1453, 1, 0, 0, 0, 1423, 1421, 1, 0, 0, 0, 1424, 1441, 3, 80, 40, 0, 1425, 1427, 5, 5, 0, 0, 1426, 1425, 1, 0, 0, 0, 1427, 1430, 1, 0, 0, 0, 1428, 1426, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 1431, 1, 0, 0, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1435, 5, 8, 0, 0, 1432, 1434, 5, 5, 0, 0, 1433, 1432, 1, 0, 0, 0, 1434, 1437, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1438, 1, 0, 0, 0, 1437, 1435, 1, 0, 0, 0, 1438, 1440, 3, 80, 40, 0, 1439, 1428, 1, 0, 0, 0, 1440, 1443, 1, 0, 0, 0, 1441, 1439, 1, 0, 0, 0, 1441, 1442, 1, 0, 0, 0, 1442, 1451, 1, 0, 0, 0, 1443, 1441, 1, 0, 0, 0, 1444, 1446, 5, 5, 0, 0, 1445, 1444, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, 1445, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1450, 1452, 5, 8, 0, 0, 1451, 1447, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 1454, 1, 0, 0, 0, 1453, 1424, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1458, 1, 0, 0, 0, 1455, 1457, 5, 5, 0, 0, 1456, 1455, 1, 0, 0, 0, 1457, 1460, 1, 0, 0, 0, 1458, 1456, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1461, 1, 0, 0, 0, 1460, 1458, 1, 0, 0, 0, 1461, 1462, 5, 10, 0, 0, 1462, 79, 1, 0, 0, 0, 1463, 1465, 3, 302, 151, 0, 1464, 1463, 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1481, 3, 82, 41, 0, 1467, 1469, 5, 5, 0, 0, 1468, 1467, 1, 0, 0, 0, 1469, 1472, 1, 0, 0, 0, 1470, 1468, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 1473, 1, 0, 0, 0, 1472, 1470, 1, 0, 0, 0, 1473, 1477, 5, 28, 0, 0, 1474, 1476, 5, 5, 0, 0, 1475, 1474, 1, 0, 0, 0, 1476, 1479, 1, 0, 0, 0, 1477, 1475, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1480, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1482, 3, 152, 76, 0, 1481, 1470, 1, 0, 0, 0, 1481, 1482, 1, 0, 0, 0, 1482, 81, 1, 0, 0, 0, 1483, 1487, 3, 344, 172, 0, 1484, 1486, 5, 5, 0, 0, 1485, 1484, 1, 0, 0, 0, 1486, 1489, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1487, 1488, 1, 0, 0, 0, 1488, 1498, 1, 0, 0, 0, 1489, 1487, 1, 0, 0, 0, 1490, 1494, 5, 26, 0, 0, 1491, 1493, 5, 5, 0, 0, 1492, 1491, 1, 0, 0, 0, 1493, 1496, 1, 0, 0, 0, 1494, 1492, 1, 0, 0, 0, 1494, 1495, 1, 0, 0, 0, 1495, 1497, 1, 0, 0, 0, 1496, 1494, 1, 0, 0, 0, 1497, 1499, 3, 98, 49, 0, 1498, 1490, 1, 0, 0, 0, 1498, 1499, 1, 0, 0, 0, 1499, 83, 1, 0, 0, 0, 1500, 1504, 3, 344, 172, 0, 1501, 1503, 5, 5, 0, 0, 1502, 1501, 1, 0, 0, 0, 1503, 1506, 1, 0, 0, 0, 1504, 1502, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1507, 1, 0, 0, 0, 1506, 1504, 1, 0, 0, 0, 1507, 1511, 5, 26, 0, 0, 1508, 1510, 5, 5, 0, 0, 1509, 1508, 1, 0, 0, 0, 1510, 1513, 1, 0, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1514, 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1514, 1515, 3, 98, 49, 0, 1515, 85, 1, 0, 0, 0, 1516, 1518, 3, 300, 150, 0, 1517, 1516, 1, 0, 0, 0, 1517, 1518, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1523, 5, 76, 0, 0, 1520, 1522, 5, 5, 0, 0, 1521, 1520, 1, 0, 0, 0, 1522, 1525, 1, 0, 0, 0, 1523, 1521, 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 1526, 1, 0, 0, 0, 1525, 1523, 1, 0, 0, 0, 1526, 1541, 3, 344, 172, 0, 1527, 1529, 5, 5, 0, 0, 1528, 1527, 1, 0, 0, 0, 1529, 1532, 1, 0, 0, 0, 1530, 1528, 1, 0, 0, 0, 1530, 1531, 1, 0, 0, 0, 1531, 1533, 1, 0, 0, 0, 1532, 1530, 1, 0, 0, 0, 1533, 1537, 5, 26, 0, 0, 1534, 1536, 5, 5, 0, 0, 1535, 1534, 1, 0, 0, 0, 1536, 1539, 1, 0, 0, 0, 1537, 1535, 1, 0, 0, 0, 1537, 1538, 1, 0, 0, 0, 1538, 1540, 1, 0, 0, 0, 1539, 1537, 1, 0, 0, 0, 1540, 1542, 3, 32, 16, 0, 1541, 1530, 1, 0, 0, 0, 1541, 1542, 1, 0, 0, 0, 1542, 1550, 1, 0, 0, 0, 1543, 1545, 5, 5, 0, 0, 1544, 1543, 1, 0, 0, 0, 1545, 1548, 1, 0, 0, 0, 1546, 1544, 1, 0, 0, 0, 1546, 1547, 1, 0, 0, 0, 1547, 1549, 1, 0, 0, 0, 1548, 1546, 1, 0, 0, 0, 1549, 1551, 3, 26, 13, 0, 1550, 1546, 1, 0, 0, 0, 1550, 1551, 1, 0, 0, 0, 1551, 87, 1, 0, 0, 0, 1552, 1554, 3, 300, 150, 0, 1553, 1552, 1, 0, 0, 0, 1553, 1554, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1559, 5, 80, 0, 0, 1556, 1558, 5, 5, 0, 0, 1557, 1556, 1, 0, 0, 0, 1558, 1561, 1, 0, 0, 0, 1559, 1557, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1562, 1, 0, 0, 0, 1561, 1559, 1, 0, 0, 0, 1562, 1577, 3, 58, 29, 0, 1563, 1565, 5, 5, 0, 0, 1564, 1563, 1, 0, 0, 0, 1565, 1568, 1, 0, 0, 0, 1566, 1564, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1569, 1, 0, 0, 0, 1568, 1566, 1, 0, 0, 0, 1569, 1573, 5, 26, 0, 0, 1570, 1572, 5, 5, 0, 0, 1571, 1570, 1, 0, 0, 0, 1572, 1575, 1, 0, 0, 0, 1573, 1571, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1576, 1, 0, 0, 0, 1575, 1573, 1, 0, 0, 0, 1576, 1578, 3, 90, 45, 0, 1577, 1566, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1582, 1, 0, 0, 0, 1579, 1581, 5, 5, 0, 0, 1580, 1579, 1, 0, 0, 0, 1581, 1584, 1, 0, 0, 0, 1582, 1580, 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1586, 1, 0, 0, 0, 1584, 1582, 1, 0, 0, 0, 1585, 1587, 3, 136, 68, 0, 1586, 1585, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 89, 1, 0, 0, 0, 1588, 1592, 7, 2, 0, 0, 1589, 1591, 5, 5, 0, 0, 1590, 1589, 1, 0, 0, 0, 1591, 1594, 1, 0, 0, 0, 1592, 1590, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 1595, 1, 0, 0, 0, 1594, 1592, 1, 0, 0, 0, 1595, 1596, 3, 208, 104, 0, 1596, 91, 1, 0, 0, 0, 1597, 1601, 5, 13, 0, 0, 1598, 1600, 5, 5, 0, 0, 1599, 1598, 1, 0, 0, 0, 1600, 1603, 1, 0, 0, 0, 1601, 1599, 1, 0, 0, 0, 1601, 1602, 1, 0, 0, 0, 1602, 1605, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1604, 1606, 3, 94, 47, 0, 1605, 1604, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1621, 1, 0, 0, 0, 1607, 1609, 5, 5, 0, 0, 1608, 1607, 1, 0, 0, 0, 1609, 1612, 1, 0, 0, 0, 1610, 1608, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1613, 1, 0, 0, 0, 1612, 1610, 1, 0, 0, 0, 1613, 1617, 5, 27, 0, 0, 1614, 1616, 5, 5, 0, 0, 1615, 1614, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1622, 3, 50, 25, 0, 1621, 1610, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1626, 1, 0, 0, 0, 1623, 1625, 5, 5, 0, 0, 1624, 1623, 1, 0, 0, 0, 1625, 1628, 1, 0, 0, 0, 1626, 1624, 1, 0, 0, 0, 1626, 1627, 1, 0, 0, 0, 1627, 1629, 1, 0, 0, 0, 1628, 1626, 1, 0, 0, 0, 1629, 1630, 5, 14, 0, 0, 1630, 93, 1, 0, 0, 0, 1631, 1648, 3, 96, 48, 0, 1632, 1634, 5, 5, 0, 0, 1633, 1632, 1, 0, 0, 0, 1634, 1637, 1, 0, 0, 0, 1635, 1633, 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 1638, 1, 0, 0, 0, 1637, 1635, 1, 0, 0, 0, 1638, 1642, 5, 8, 0, 0, 1639, 1641, 5, 5, 0, 0, 1640, 1639, 1, 0, 0, 0, 1641, 1644, 1, 0, 0, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1645, 1, 0, 0, 0, 1644, 1642, 1, 0, 0, 0, 1645, 1647, 3, 96, 48, 0, 1646, 1635, 1, 0, 0, 0, 1647, 1650, 1, 0, 0, 0, 1648, 1646, 1, 0, 0, 0, 1648, 1649, 1, 0, 0, 0, 1649, 1654, 1, 0, 0, 0, 1650, 1648, 1, 0, 0, 0, 1651, 1653, 5, 5, 0, 0, 1652, 1651, 1, 0, 0, 0, 1653, 1656, 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1658, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1659, 5, 8, 0, 0, 1658, 1657, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 95, 1, 0, 0, 0, 1660, 1664, 3, 300, 150, 0, 1661, 1663, 5, 5, 0, 0, 1662, 1661, 1, 0, 0, 0, 1663, 1666, 1, 0, 0, 0, 1664, 1662, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 1668, 1, 0, 0, 0, 1666, 1664, 1, 0, 0, 0, 1667, 1660, 1, 0, 0, 0, 1667, 1668, 1, 0, 0, 0, 1668, 1669, 1, 0, 0, 0, 1669, 1677, 3, 344, 172, 0, 1670, 1672, 5, 5, 0, 0, 1671, 1670, 1, 0, 0, 0, 1672, 1675, 1, 0, 0, 0, 1673, 1671, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1676, 1, 0, 0, 0, 1675, 1673, 1, 0, 0, 0, 1676, 1678, 3, 208, 104, 0, 1677, 1673, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1686, 1, 0, 0, 0, 1679, 1681, 5, 5, 0, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 1685, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1685, 1687, 3, 26, 13, 0, 1686, 1682, 1, 0, 0, 0, 1686, 1687, 1, 0, 0, 0, 1687, 97, 1, 0, 0, 0, 1688, 1690, 3, 306, 153, 0, 1689, 1688, 1, 0, 0, 0, 1689, 1690, 1, 0, 0, 0, 1690, 1696, 1, 0, 0, 0, 1691, 1697, 3, 116, 58, 0, 1692, 1697, 3, 120, 60, 0, 1693, 1697, 3, 102, 51, 0, 1694, 1697, 3, 100, 50, 0, 1695, 1697, 3, 126, 63, 0, 1696, 1691, 1, 0, 0, 0, 1696, 1692, 1, 0, 0, 0, 1696, 1693, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1696, 1695, 1, 0, 0, 0, 1697, 99, 1, 0, 0, 0, 1698, 1701, 3, 106, 53, 0, 1699, 1701, 5, 107, 0, 0, 1700, 1698, 1, 0, 0, 0, 1700, 1699, 1, 0, 0, 0, 1701, 101, 1, 0, 0, 0, 1702, 1705, 3, 100, 50, 0, 1703, 1705, 3, 120, 60, 0, 1704, 1702, 1, 0, 0, 0, 1704, 1703, 1, 0, 0, 0, 1705, 1709, 1, 0, 0, 0, 1706, 1708, 5, 5, 0, 0, 1707, 1706, 1, 0, 0, 0, 1708, 1711, 1, 0, 0, 0, 1709, 1707, 1, 0, 0, 0, 1709, 1710, 1, 0, 0, 0, 1710, 1713, 1, 0, 0, 0, 1711, 1709, 1, 0, 0, 0, 1712, 1714, 3, 104, 52, 0, 1713, 1712, 1, 0, 0, 0, 1714, 1715, 1, 0, 0, 0, 1715, 1713, 1, 0, 0, 0, 1715, 1716, 1, 0, 0, 0, 1716, 103, 1, 0, 0, 0, 1717, 1718, 7, 3, 0, 0, 1718, 105, 1, 0, 0, 0, 1719, 1736, 3, 108, 54, 0, 1720, 1722, 5, 5, 0, 0, 1721, 1720, 1, 0, 0, 0, 1722, 1725, 1, 0, 0, 0, 1723, 1721, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1726, 1, 0, 0, 0, 1725, 1723, 1, 0, 0, 0, 1726, 1730, 5, 7, 0, 0, 1727, 1729, 5, 5, 0, 0, 1728, 1727, 1, 0, 0, 0, 1729, 1732, 1, 0, 0, 0, 1730, 1728, 1, 0, 0, 0, 1730, 1731, 1, 0, 0, 0, 1731, 1733, 1, 0, 0, 0, 1732, 1730, 1, 0, 0, 0, 1733, 1735, 3, 108, 54, 0, 1734, 1723, 1, 0, 0, 0, 1735, 1738, 1, 0, 0, 0, 1736, 1734, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 107, 1, 0, 0, 0, 1738, 1736, 1, 0, 0, 0, 1739, 1747, 3, 344, 172, 0, 1740, 1742, 5, 5, 0, 0, 1741, 1740, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1746, 1748, 3, 206, 103, 0, 1747, 1743, 1, 0, 0, 0, 1747, 1748, 1, 0, 0, 0, 1748, 109, 1, 0, 0, 0, 1749, 1751, 3, 112, 56, 0, 1750, 1749, 1, 0, 0, 0, 1750, 1751, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1755, 3, 98, 49, 0, 1753, 1755, 5, 15, 0, 0, 1754, 1750, 1, 0, 0, 0, 1754, 1753, 1, 0, 0, 0, 1755, 111, 1, 0, 0, 0, 1756, 1758, 3, 114, 57, 0, 1757, 1756, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1757, 1, 0, 0, 0, 1759, 1760, 1, 0, 0, 0, 1760, 113, 1, 0, 0, 0, 1761, 1765, 3, 316, 158, 0, 1762, 1764, 5, 5, 0, 0, 1763, 1762, 1, 0, 0, 0, 1764, 1767, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0, 1765, 1766, 1, 0, 0, 0, 1766, 1770, 1, 0, 0, 0, 1767, 1765, 1, 0, 0, 0, 1768, 1770, 3, 334, 167, 0, 1769, 1761, 1, 0, 0, 0, 1769, 1768, 1, 0, 0, 0, 1770, 115, 1, 0, 0, 0, 1771, 1775, 3, 122, 61, 0, 1772, 1774, 5, 5, 0, 0, 1773, 1772, 1, 0, 0, 0, 1774, 1777, 1, 0, 0, 0, 1775, 1773, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1778, 1, 0, 0, 0, 1777, 1775, 1, 0, 0, 0, 1778, 1782, 5, 7, 0, 0, 1779, 1781, 5, 5, 0, 0, 1780, 1779, 1, 0, 0, 0, 1781, 1784, 1, 0, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1783, 1, 0, 0, 0, 1783, 1786, 1, 0, 0, 0, 1784, 1782, 1, 0, 0, 0, 1785, 1771, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1791, 3, 118, 59, 0, 1788, 1790, 5, 5, 0, 0, 1789, 1788, 1, 0, 0, 0, 1790, 1793, 1, 0, 0, 0, 1791, 1789, 1, 0, 0, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1794, 1, 0, 0, 0, 1793, 1791, 1, 0, 0, 0, 1794, 1798, 5, 34, 0, 0, 1795, 1797, 5, 5, 0, 0, 1796, 1795, 1, 0, 0, 0, 1797, 1800, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1798, 1799, 1, 0, 0, 0, 1799, 1801, 1, 0, 0, 0, 1800, 1798, 1, 0, 0, 0, 1801, 1802, 3, 98, 49, 0, 1802, 117, 1, 0, 0, 0, 1803, 1807, 5, 9, 0, 0, 1804, 1806, 5, 5, 0, 0, 1805, 1804, 1, 0, 0, 0, 1806, 1809, 1, 0, 0, 0, 1807, 1805, 1, 0, 0, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1812, 1, 0, 0, 0, 1809, 1807, 1, 0, 0, 0, 1810, 1813, 3, 84, 42, 0, 1811, 1813, 3, 98, 49, 0, 1812, 1810, 1, 0, 0, 0, 1812, 1811, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1833, 1, 0, 0, 0, 1814, 1816, 5, 5, 0, 0, 1815, 1814, 1, 0, 0, 0, 1816, 1819, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1820, 1, 0, 0, 0, 1819, 1817, 1, 0, 0, 0, 1820, 1824, 5, 8, 0, 0, 1821, 1823, 5, 5, 0, 0, 1822, 1821, 1, 0, 0, 0, 1823, 1826, 1, 0, 0, 0, 1824, 1822, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1829, 1, 0, 0, 0, 1826, 1824, 1, 0, 0, 0, 1827, 1830, 3, 84, 42, 0, 1828, 1830, 3, 98, 49, 0, 1829, 1827, 1, 0, 0, 0, 1829, 1828, 1, 0, 0, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1817, 1, 0, 0, 0, 1832, 1835, 1, 0, 0, 0, 1833, 1831, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1843, 1, 0, 0, 0, 1835, 1833, 1, 0, 0, 0, 1836, 1838, 5, 5, 0, 0, 1837, 1836, 1, 0, 0, 0, 1838, 1841, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1842, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1842, 1844, 5, 8, 0, 0, 1843, 1839, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1848, 1, 0, 0, 0, 1845, 1847, 5, 5, 0, 0, 1846, 1845, 1, 0, 0, 0, 1847, 1850, 1, 0, 0, 0, 1848, 1846, 1, 0, 0, 0, 1848, 1849, 1, 0, 0, 0, 1849, 1851, 1, 0, 0, 0, 1850, 1848, 1, 0, 0, 0, 1851, 1852, 5, 10, 0, 0, 1852, 119, 1, 0, 0, 0, 1853, 1857, 5, 9, 0, 0, 1854, 1856, 5, 5, 0, 0, 1855, 1854, 1, 0, 0, 0, 1856, 1859, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1860, 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1860, 1864, 3, 98, 49, 0, 1861, 1863, 5, 5, 0, 0, 1862, 1861, 1, 0, 0, 0, 1863, 1866, 1, 0, 0, 0, 1864, 1862, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1867, 1, 0, 0, 0, 1866, 1864, 1, 0, 0, 0, 1867, 1868, 5, 10, 0, 0, 1868, 121, 1, 0, 0, 0, 1869, 1871, 3, 306, 153, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1875, 1, 0, 0, 0, 1872, 1876, 3, 120, 60, 0, 1873, 1876, 3, 102, 51, 0, 1874, 1876, 3, 100, 50, 0, 1875, 1872, 1, 0, 0, 0, 1875, 1873, 1, 0, 0, 0, 1875, 1874, 1, 0, 0, 0, 1876, 123, 1, 0, 0, 0, 1877, 1881, 5, 9, 0, 0, 1878, 1880, 5, 5, 0, 0, 1879, 1878, 1, 0, 0, 0, 1880, 1883, 1, 0, 0, 0, 1881, 1879, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1886, 1, 0, 0, 0, 1883, 1881, 1, 0, 0, 0, 1884, 1887, 3, 106, 53, 0, 1885, 1887, 3, 124, 62, 0, 1886, 1884, 1, 0, 0, 0, 1886, 1885, 1, 0, 0, 0, 1887, 1891, 1, 0, 0, 0, 1888, 1890, 5, 5, 0, 0, 1889, 1888, 1, 0, 0, 0, 1890, 1893, 1, 0, 0, 0, 1891, 1889, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1894, 1, 0, 0, 0, 1893, 1891, 1, 0, 0, 0, 1894, 1895, 5, 10, 0, 0, 1895, 125, 1, 0, 0, 0, 1896, 1898, 3, 306, 153, 0, 1897, 1896, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1901, 1, 0, 0, 0, 1899, 1902, 3, 106, 53, 0, 1900, 1902, 3, 124, 62, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1900, 1, 0, 0, 0, 1902, 1906, 1, 0, 0, 0, 1903, 1905, 5, 5, 0, 0, 1904, 1903, 1, 0, 0, 0, 1905, 1908, 1, 0, 0, 0, 1906, 1904, 1, 0, 0, 0, 1906, 1907, 1, 0, 0, 0, 1907, 1909, 1, 0, 0, 0, 1908, 1906, 1, 0, 0, 0, 1909, 1913, 5, 56, 0, 0, 1910, 1912, 5, 5, 0, 0, 1911, 1910, 1, 0, 0, 0, 1912, 1915, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 1917, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1916, 1918, 3, 306, 153, 0, 1917, 1916, 1, 0, 0, 0, 1917, 1918, 1, 0, 0, 0, 1918, 1921, 1, 0, 0, 0, 1919, 1922, 3, 106, 53, 0, 1920, 1922, 3, 124, 62, 0, 1921, 1919, 1, 0, 0, 0, 1921, 1920, 1, 0, 0, 0, 1922, 127, 1, 0, 0, 0, 1923, 1929, 3, 130, 65, 0, 1924, 1925, 3, 150, 75, 0, 1925, 1926, 3, 130, 65, 0, 1926, 1928, 1, 0, 0, 0, 1927, 1924, 1, 0, 0, 0, 1928, 1931, 1, 0, 0, 0, 1929, 1927, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1933, 1, 0, 0, 0, 1931, 1929, 1, 0, 0, 0, 1932, 1923, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1936, 3, 150, 75, 0, 1935, 1934, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0, 1936, 129, 1, 0, 0, 0, 1937, 1940, 3, 132, 66, 0, 1938, 1940, 3, 334, 167, 0, 1939, 1937, 1, 0, 0, 0, 1939, 1938, 1, 0, 0, 0, 1940, 1943, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1948, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, 1944, 1949, 3, 20, 10, 0, 1945, 1949, 3, 146, 73, 0, 1946, 1949, 3, 138, 69, 0, 1947, 1949, 3, 152, 76, 0, 1948, 1944, 1, 0, 0, 0, 1948, 1945, 1, 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1948, 1947, 1, 0, 0, 0, 1949, 131, 1, 0, 0, 0, 1950, 1951, 3, 344, 172, 0, 1951, 1955, 7, 4, 0, 0, 1952, 1954, 5, 5, 0, 0, 1953, 1952, 1, 0, 0, 0, 1954, 1957, 1, 0, 0, 0, 1955, 1953, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 133, 1, 0, 0, 0, 1957, 1955, 1, 0, 0, 0, 1958, 1961, 3, 136, 68, 0, 1959, 1961, 3, 130, 65, 0, 1960, 1958, 1, 0, 0, 0, 1960, 1959, 1, 0, 0, 0, 1961, 135, 1, 0, 0, 0, 1962, 1966, 5, 13, 0, 0, 1963, 1965, 5, 5, 0, 0, 1964, 1963, 1, 0, 0, 0, 1965, 1968, 1, 0, 0, 0, 1966, 1964, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1969, 1, 0, 0, 0, 1968, 1966, 1, 0, 0, 0, 1969, 1973, 3, 128, 64, 0, 1970, 1972, 5, 5, 0, 0, 1971, 1970, 1, 0, 0, 0, 1972, 1975, 1, 0, 0, 0, 1973, 1971, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1976, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1976, 1977, 5, 14, 0, 0, 1977, 137, 1, 0, 0, 0, 1978, 1982, 3, 140, 70, 0, 1979, 1982, 3, 142, 71, 0, 1980, 1982, 3, 144, 72, 0, 1981, 1978, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1981, 1980, 1, 0, 0, 0, 1982, 139, 1, 0, 0, 0, 1983, 1987, 5, 94, 0, 0, 1984, 1986, 5, 5, 0, 0, 1985, 1984, 1, 0, 0, 0, 1986, 1989, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, 1987, 1988, 1, 0, 0, 0, 1988, 1990, 1, 0, 0, 0, 1989, 1987, 1, 0, 0, 0, 1990, 1994, 5, 9, 0, 0, 1991, 1993, 3, 334, 167, 0, 1992, 1991, 1, 0, 0, 0, 1993, 1996, 1, 0, 0, 0, 1994, 1992, 1, 0, 0, 0, 1994, 1995, 1, 0, 0, 0, 1995, 1999, 1, 0, 0, 0, 1996, 1994, 1, 0, 0, 0, 1997, 2000, 3, 66, 33, 0, 1998, 2000, 3, 68, 34, 0, 1999, 1997, 1, 0, 0, 0, 1999, 1998, 1, 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2002, 5, 103, 0, 0, 2002, 2003, 3, 152, 76, 0, 2003, 2007, 5, 10, 0, 0, 2004, 2006, 5, 5, 0, 0, 2005, 2004, 1, 0, 0, 0, 2006, 2009, 1, 0, 0, 0, 2007, 2005, 1, 0, 0, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2011, 1, 0, 0, 0, 2009, 2007, 1, 0, 0, 0, 2010, 2012, 3, 134, 67, 0, 2011, 2010, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 141, 1, 0, 0, 0, 2013, 2017, 5, 96, 0, 0, 2014, 2016, 5, 5, 0, 0, 2015, 2014, 1, 0, 0, 0, 2016, 2019, 1, 0, 0, 0, 2017, 2015, 1, 0, 0, 0, 2017, 2018, 1, 0, 0, 0, 2018, 2020, 1, 0, 0, 0, 2019, 2017, 1, 0, 0, 0, 2020, 2021, 5, 9, 0, 0, 2021, 2022, 3, 152, 76, 0, 2022, 2026, 5, 10, 0, 0, 2023, 2025, 5, 5, 0, 0, 2024, 2023, 1, 0, 0, 0, 2025, 2028, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 2031, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2029, 2032, 3, 134, 67, 0, 2030, 2032, 5, 27, 0, 0, 2031, 2029, 1, 0, 0, 0, 2031, 2030, 1, 0, 0, 0, 2032, 143, 1, 0, 0, 0, 2033, 2037, 5, 95, 0, 0, 2034, 2036, 5, 5, 0, 0, 2035, 2034, 1, 0, 0, 0, 2036, 2039, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2041, 1, 0, 0, 0, 2039, 2037, 1, 0, 0, 0, 2040, 2042, 3, 134, 67, 0, 2041, 2040, 1, 0, 0, 0, 2041, 2042, 1, 0, 0, 0, 2042, 2046, 1, 0, 0, 0, 2043, 2045, 5, 5, 0, 0, 2044, 2043, 1, 0, 0, 0, 2045, 2048, 1, 0, 0, 0, 2046, 2044, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2049, 1, 0, 0, 0, 2048, 2046, 1, 0, 0, 0, 2049, 2053, 5, 96, 0, 0, 2050, 2052, 5, 5, 0, 0, 2051, 2050, 1, 0, 0, 0, 2052, 2055, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2053, 2054, 1, 0, 0, 0, 2054, 2056, 1, 0, 0, 0, 2055, 2053, 1, 0, 0, 0, 2056, 2057, 5, 9, 0, 0, 2057, 2058, 3, 152, 76, 0, 2058, 2059, 5, 10, 0, 0, 2059, 145, 1, 0, 0, 0, 2060, 2061, 3, 188, 94, 0, 2061, 2062, 5, 28, 0, 0, 2062, 2067, 1, 0, 0, 0, 2063, 2064, 3, 192, 96, 0, 2064, 2065, 3, 274, 137, 0, 2065, 2067, 1, 0, 0, 0, 2066, 2060, 1, 0, 0, 0, 2066, 2063, 1, 0, 0, 0, 2067, 2071, 1, 0, 0, 0, 2068, 2070, 5, 5, 0, 0, 2069, 2068, 1, 0, 0, 0, 2070, 2073, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2074, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2074, 2075, 3, 152, 76, 0, 2075, 147, 1, 0, 0, 0, 2076, 2080, 7, 5, 0, 0, 2077, 2079, 5, 5, 0, 0, 2078, 2077, 1, 0, 0, 0, 2079, 2082, 1, 0, 0, 0, 2080, 2078, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 149, 1, 0, 0, 0, 2082, 2080, 1, 0, 0, 0, 2083, 2085, 7, 5, 0, 0, 2084, 2083, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2084, 1, 0, 0, 0, 2086, 2087, 1, 0, 0, 0, 2087, 151, 1, 0, 0, 0, 2088, 2089, 3, 154, 77, 0, 2089, 153, 1, 0, 0, 0, 2090, 2107, 3, 156, 78, 0, 2091, 2093, 5, 5, 0, 0, 2092, 2091, 1, 0, 0, 0, 2093, 2096, 1, 0, 0, 0, 2094, 2092, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 2097, 1, 0, 0, 0, 2096, 2094, 1, 0, 0, 0, 2097, 2101, 5, 23, 0, 0, 2098, 2100, 5, 5, 0, 0, 2099, 2098, 1, 0, 0, 0, 2100, 2103, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2104, 1, 0, 0, 0, 2103, 2101, 1, 0, 0, 0, 2104, 2106, 3, 156, 78, 0, 2105, 2094, 1, 0, 0, 0, 2106, 2109, 1, 0, 0, 0, 2107, 2105, 1, 0, 0, 0, 2107, 2108, 1, 0, 0, 0, 2108, 155, 1, 0, 0, 0, 2109, 2107, 1, 0, 0, 0, 2110, 2127, 3, 158, 79, 0, 2111, 2113, 5, 5, 0, 0, 2112, 2111, 1, 0, 0, 0, 2113, 2116, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2117, 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2117, 2121, 5, 22, 0, 0, 2118, 2120, 5, 5, 0, 0, 2119, 2118, 1, 0, 0, 0, 2120, 2123, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 2124, 1, 0, 0, 0, 2123, 2121, 1, 0, 0, 0, 2124, 2126, 3, 158, 79, 0, 2125, 2114, 1, 0, 0, 0, 2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 157, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2130, 2142, 3, 160, 80, 0, 2131, 2135, 3, 276, 138, 0, 2132, 2134, 5, 5, 0, 0, 2133, 2132, 1, 0, 0, 0, 2134, 2137, 1, 0, 0, 0, 2135, 2133, 1, 0, 0, 0, 2135, 2136, 1, 0, 0, 0, 2136, 2138, 1, 0, 0, 0, 2137, 2135, 1, 0, 0, 0, 2138, 2139, 3, 160, 80, 0, 2139, 2141, 1, 0, 0, 0, 2140, 2131, 1, 0, 0, 0, 2141, 2144, 1, 0, 0, 0, 2142, 2140, 1, 0, 0, 0, 2142, 2143, 1, 0, 0, 0, 2143, 159, 1, 0, 0, 0, 2144, 2142, 1, 0, 0, 0, 2145, 2157, 3, 162, 81, 0, 2146, 2150, 3, 278, 139, 0, 2147, 2149, 5, 5, 0, 0, 2148, 2147, 1, 0, 0, 0, 2149, 2152, 1, 0, 0, 0, 2150, 2148, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151, 2153, 1, 0, 0, 0, 2152, 2150, 1, 0, 0, 0, 2153, 2154, 3, 162, 81, 0, 2154, 2156, 1, 0, 0, 0, 2155, 2146, 1, 0, 0, 0, 2156, 2159, 1, 0, 0, 0, 2157, 2155, 1, 0, 0, 0, 2157, 2158, 1, 0, 0, 0, 2158, 161, 1, 0, 0, 0, 2159, 2157, 1, 0, 0, 0, 2160, 2164, 3, 164, 82, 0, 2161, 2163, 3, 202, 101, 0, 2162, 2161, 1, 0, 0, 0, 2163, 2166, 1, 0, 0, 0, 2164, 2162, 1, 0, 0, 0, 2164, 2165, 1, 0, 0, 0, 2165, 163, 1, 0, 0, 0, 2166, 2164, 1, 0, 0, 0, 2167, 2188, 3, 166, 83, 0, 2168, 2172, 3, 280, 140, 0, 2169, 2171, 5, 5, 0, 0, 2170, 2169, 1, 0, 0, 0, 2171, 2174, 1, 0, 0, 0, 2172, 2170, 1, 0, 0, 0, 2172, 2173, 1, 0, 0, 0, 2173, 2175, 1, 0, 0, 0, 2174, 2172, 1, 0, 0, 0, 2175, 2176, 3, 166, 83, 0, 2176, 2187, 1, 0, 0, 0, 2177, 2181, 3, 282, 141, 0, 2178, 2180, 5, 5, 0, 0, 2179, 2178, 1, 0, 0, 0, 2180, 2183, 1, 0, 0, 0, 2181, 2179, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, 2184, 1, 0, 0, 0, 2183, 2181, 1, 0, 0, 0, 2184, 2185, 3, 98, 49, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2168, 1, 0, 0, 0, 2186, 2177, 1, 0, 0, 0, 2187, 2190, 1, 0, 0, 0, 2188, 2186, 1, 0, 0, 0, 2188, 2189, 1, 0, 0, 0, 2189, 165, 1, 0, 0, 0, 2190, 2188, 1, 0, 0, 0, 2191, 2209, 3, 170, 85, 0, 2192, 2194, 5, 5, 0, 0, 2193, 2192, 1, 0, 0, 0, 2194, 2197, 1, 0, 0, 0, 2195, 2193, 1, 0, 0, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2198, 1, 0, 0, 0, 2197, 2195, 1, 0, 0, 0, 2198, 2202, 3, 168, 84, 0, 2199, 2201, 5, 5, 0, 0, 2200, 2199, 1, 0, 0, 0, 2201, 2204, 1, 0, 0, 0, 2202, 2200, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2205, 1, 0, 0, 0, 2204, 2202, 1, 0, 0, 0, 2205, 2206, 3, 170, 85, 0, 2206, 2208, 1, 0, 0, 0, 2207, 2195, 1, 0, 0, 0, 2208, 2211, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2209, 2210, 1, 0, 0, 0, 2210, 167, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2212, 2213, 5, 45, 0, 0, 2213, 2214, 5, 26, 0, 0, 2214, 169, 1, 0, 0, 0, 2215, 2227, 3, 172, 86, 0, 2216, 2220, 3, 344, 172, 0, 2217, 2219, 5, 5, 0, 0, 2218, 2217, 1, 0, 0, 0, 2219, 2222, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2220, 2221, 1, 0, 0, 0, 2221, 2223, 1, 0, 0, 0, 2222, 2220, 1, 0, 0, 0, 2223, 2224, 3, 172, 86, 0, 2224, 2226, 1, 0, 0, 0, 2225, 2216, 1, 0, 0, 0, 2226, 2229, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 171, 1, 0, 0, 0, 2229, 2227, 1, 0, 0, 0, 2230, 2241, 3, 174, 87, 0, 2231, 2235, 5, 36, 0, 0, 2232, 2234, 5, 5, 0, 0, 2233, 2232, 1, 0, 0, 0, 2234, 2237, 1, 0, 0, 0, 2235, 2233, 1, 0, 0, 0, 2235, 2236, 1, 0, 0, 0, 2236, 2238, 1, 0, 0, 0, 2237, 2235, 1, 0, 0, 0, 2238, 2240, 3, 174, 87, 0, 2239, 2231, 1, 0, 0, 0, 2240, 2243, 1, 0, 0, 0, 2241, 2239, 1, 0, 0, 0, 2241, 2242, 1, 0, 0, 0, 2242, 173, 1, 0, 0, 0, 2243, 2241, 1, 0, 0, 0, 2244, 2256, 3, 176, 88, 0, 2245, 2249, 3, 284, 142, 0, 2246, 2248, 5, 5, 0, 0, 2247, 2246, 1, 0, 0, 0, 2248, 2251, 1, 0, 0, 0, 2249, 2247, 1, 0, 0, 0, 2249, 2250, 1, 0, 0, 0, 2250, 2252, 1, 0, 0, 0, 2251, 2249, 1, 0, 0, 0, 2252, 2253, 3, 176, 88, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2245, 1, 0, 0, 0, 2255, 2258, 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 175, 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2271, 3, 178, 89, 0, 2260, 2264, 3, 286, 143, 0, 2261, 2263, 5, 5, 0, 0, 2262, 2261, 1, 0, 0, 0, 2263, 2266, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 2267, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2267, 2268, 3, 178, 89, 0, 2268, 2270, 1, 0, 0, 0, 2269, 2260, 1, 0, 0, 0, 2270, 2273, 1, 0, 0, 0, 2271, 2269, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 177, 1, 0, 0, 0, 2273, 2271, 1, 0, 0, 0, 2274, 2292, 3, 180, 90, 0, 2275, 2277, 5, 5, 0, 0, 2276, 2275, 1, 0, 0, 0, 2277, 2280, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2278, 2279, 1, 0, 0, 0, 2279, 2281, 1, 0, 0, 0, 2280, 2278, 1, 0, 0, 0, 2281, 2285, 3, 288, 144, 0, 2282, 2284, 5, 5, 0, 0, 2283, 2282, 1, 0, 0, 0, 2284, 2287, 1, 0, 0, 0, 2285, 2283, 1, 0, 0, 0, 2285, 2286, 1, 0, 0, 0, 2286, 2288, 1, 0, 0, 0, 2287, 2285, 1, 0, 0, 0, 2288, 2289, 3, 98, 49, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2278, 1, 0, 0, 0, 2291, 2294, 1, 0, 0, 0, 2292, 2290, 1, 0, 0, 0, 2292, 2293, 1, 0, 0, 0, 2293, 179, 1, 0, 0, 0, 2294, 2292, 1, 0, 0, 0, 2295, 2297, 3, 182, 91, 0, 2296, 2295, 1, 0, 0, 0, 2297, 2300, 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2298, 2299, 1, 0, 0, 0, 2299, 2301, 1, 0, 0, 0, 2300, 2298, 1, 0, 0, 0, 2301, 2302, 3, 184, 92, 0, 2302, 181, 1, 0, 0, 0, 2303, 2313, 3, 334, 167, 0, 2304, 2313, 3, 132, 66, 0, 2305, 2309, 3, 290, 145, 0, 2306, 2308, 5, 5, 0, 0, 2307, 2306, 1, 0, 0, 0, 2308, 2311, 1, 0, 0, 0, 2309, 2307, 1, 0, 0, 0, 2309, 2310, 1, 0, 0, 0, 2310, 2313, 1, 0, 0, 0, 2311, 2309, 1, 0, 0, 0, 2312, 2303, 1, 0, 0, 0, 2312, 2304, 1, 0, 0, 0, 2312, 2305, 1, 0, 0, 0, 2313, 183, 1, 0, 0, 0, 2314, 2318, 3, 212, 106, 0, 2315, 2317, 3, 186, 93, 0, 2316, 2315, 1, 0, 0, 0, 2317, 2320, 1, 0, 0, 0, 2318, 2316, 1, 0, 0, 0, 2318, 2319, 1, 0, 0, 0, 2319, 185, 1, 0, 0, 0, 2320, 2318, 1, 0, 0, 0, 2321, 2327, 3, 292, 146, 0, 2322, 2327, 3, 206, 103, 0, 2323, 2327, 3, 202, 101, 0, 2324, 2327, 3, 198, 99, 0, 2325, 2327, 3, 200, 100, 0, 2326, 2321, 1, 0, 0, 0, 2326, 2322, 1, 0, 0, 0, 2326, 2323, 1, 0, 0, 0, 2326, 2324, 1, 0, 0, 0, 2326, 2325, 1, 0, 0, 0, 2327, 187, 1, 0, 0, 0, 2328, 2329, 3, 184, 92, 0, 2329, 2330, 3, 196, 98, 0, 2330, 2334, 1, 0, 0, 0, 2331, 2334, 3, 344, 172, 0, 2332, 2334, 3, 190, 95, 0, 2333, 2328, 1, 0, 0, 0, 2333, 2331, 1, 0, 0, 0, 2333, 2332, 1, 0, 0, 0, 2334, 189, 1, 0, 0, 0, 2335, 2339, 5, 9, 0, 0, 2336, 2338, 5, 5, 0, 0, 2337, 2336, 1, 0, 0, 0, 2338, 2341, 1, 0, 0, 0, 2339, 2337, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, 0, 2340, 2342, 1, 0, 0, 0, 2341, 2339, 1, 0, 0, 0, 2342, 2346, 3, 188, 94, 0, 2343, 2345, 5, 5, 0, 0, 2344, 2343, 1, 0, 0, 0, 2345, 2348, 1, 0, 0, 0, 2346, 2344, 1, 0, 0, 0, 2346, 2347, 1, 0, 0, 0, 2347, 2349, 1, 0, 0, 0, 2348, 2346, 1, 0, 0, 0, 2349, 2350, 5, 10, 0, 0, 2350, 191, 1, 0, 0, 0, 2351, 2354, 3, 180, 90, 0, 2352, 2354, 3, 194, 97, 0, 2353, 2351, 1, 0, 0, 0, 2353, 2352, 1, 0, 0, 0, 2354, 193, 1, 0, 0, 0, 2355, 2359, 5, 9, 0, 0, 2356, 2358, 5, 5, 0, 0, 2357, 2356, 1, 0, 0, 0, 2358, 2361, 1, 0, 0, 0, 2359, 2357, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2362, 1, 0, 0, 0, 2361, 2359, 1, 0, 0, 0, 2362, 2366, 3, 192, 96, 0, 2363, 2365, 5, 5, 0, 0, 2364, 2363, 1, 0, 0, 0, 2365, 2368, 1, 0, 0, 0, 2366, 2364, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2369, 1, 0, 0, 0, 2368, 2366, 1, 0, 0, 0, 2369, 2370, 5, 10, 0, 0, 2370, 195, 1, 0, 0, 0, 2371, 2375, 3, 206, 103, 0, 2372, 2375, 3, 198, 99, 0, 2373, 2375, 3, 200, 100, 0, 2374, 2371, 1, 0, 0, 0, 2374, 2372, 1, 0, 0, 0, 2374, 2373, 1, 0, 0, 0, 2375, 197, 1, 0, 0, 0, 2376, 2380, 5, 11, 0, 0, 2377, 2379, 5, 5, 0, 0, 2378, 2377, 1, 0, 0, 0, 2379, 2382, 1, 0, 0, 0, 2380, 2378, 1, 0, 0, 0, 2380, 2381, 1, 0, 0, 0, 2381, 2383, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, 0, 2383, 2400, 3, 152, 76, 0, 2384, 2386, 5, 5, 0, 0, 2385, 2384, 1, 0, 0, 0, 2386, 2389, 1, 0, 0, 0, 2387, 2385, 1, 0, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 2390, 1, 0, 0, 0, 2389, 2387, 1, 0, 0, 0, 2390, 2394, 5, 8, 0, 0, 2391, 2393, 5, 5, 0, 0, 2392, 2391, 1, 0, 0, 0, 2393, 2396, 1, 0, 0, 0, 2394, 2392, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2397, 1, 0, 0, 0, 2396, 2394, 1, 0, 0, 0, 2397, 2399, 3, 152, 76, 0, 2398, 2387, 1, 0, 0, 0, 2399, 2402, 1, 0, 0, 0, 2400, 2398, 1, 0, 0, 0, 2400, 2401, 1, 0, 0, 0, 2401, 2410, 1, 0, 0, 0, 2402, 2400, 1, 0, 0, 0, 2403, 2405, 5, 5, 0, 0, 2404, 2403, 1, 0, 0, 0, 2405, 2408, 1, 0, 0, 0, 2406, 2404, 1, 0, 0, 0, 2406, 2407, 1, 0, 0, 0, 2407, 2409, 1, 0, 0, 0, 2408, 2406, 1, 0, 0, 0, 2409, 2411, 5, 8, 0, 0, 2410, 2406, 1, 0, 0, 0, 2410, 2411, 1, 0, 0, 0, 2411, 2415, 1, 0, 0, 0, 2412, 2414, 5, 5, 0, 0, 2413, 2412, 1, 0, 0, 0, 2414, 2417, 1, 0, 0, 0, 2415, 2413, 1, 0, 0, 0, 2415, 2416, 1, 0, 0, 0, 2416, 2418, 1, 0, 0, 0, 2417, 2415, 1, 0, 0, 0, 2418, 2419, 5, 12, 0, 0, 2419, 199, 1, 0, 0, 0, 2420, 2424, 3, 296, 148, 0, 2421, 2423, 5, 5, 0, 0, 2422, 2421, 1, 0, 0, 0, 2423, 2426, 1, 0, 0, 0, 2424, 2422, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2430, 1, 0, 0, 0, 2426, 2424, 1, 0, 0, 0, 2427, 2431, 3, 344, 172, 0, 2428, 2431, 3, 214, 107, 0, 2429, 2431, 5, 73, 0, 0, 2430, 2427, 1, 0, 0, 0, 2430, 2428, 1, 0, 0, 0, 2430, 2429, 1, 0, 0, 0, 2431, 201, 1, 0, 0, 0, 2432, 2434, 3, 206, 103, 0, 2433, 2432, 1, 0, 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2440, 1, 0, 0, 0, 2435, 2437, 3, 208, 104, 0, 2436, 2435, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2441, 3, 204, 102, 0, 2439, 2441, 3, 208, 104, 0, 2440, 2436, 1, 0, 0, 0, 2440, 2439, 1, 0, 0, 0, 2441, 203, 1, 0, 0, 0, 2442, 2444, 3, 334, 167, 0, 2443, 2442, 1, 0, 0, 0, 2444, 2447, 1, 0, 0, 0, 2445, 2443, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2449, 1, 0, 0, 0, 2447, 2445, 1, 0, 0, 0, 2448, 2450, 3, 132, 66, 0, 2449, 2448, 1, 0, 0, 0, 2449, 2450, 1, 0, 0, 0, 2450, 2454, 1, 0, 0, 0, 2451, 2453, 5, 5, 0, 0, 2452, 2451, 1, 0, 0, 0, 2453, 2456, 1, 0, 0, 0, 2454, 2452, 1, 0, 0, 0, 2454, 2455, 1, 0, 0, 0, 2455, 2457, 1, 0, 0, 0, 2456, 2454, 1, 0, 0, 0, 2457, 2458, 3, 234, 117, 0, 2458, 205, 1, 0, 0, 0, 2459, 2463, 5, 46, 0, 0, 2460, 2462, 5, 5, 0, 0, 2461, 2460, 1, 0, 0, 0, 2462, 2465, 1, 0, 0, 0, 2463, 2461, 1, 0, 0, 0, 2463, 2464, 1, 0, 0, 0, 2464, 2466, 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2466, 2483, 3, 110, 55, 0, 2467, 2469, 5, 5, 0, 0, 2468, 2467, 1, 0, 0, 0, 2469, 2472, 1, 0, 0, 0, 2470, 2468, 1, 0, 0, 0, 2470, 2471, 1, 0, 0, 0, 2471, 2473, 1, 0, 0, 0, 2472, 2470, 1, 0, 0, 0, 2473, 2477, 5, 8, 0, 0, 2474, 2476, 5, 5, 0, 0, 2475, 2474, 1, 0, 0, 0, 2476, 2479, 1, 0, 0, 0, 2477, 2475, 1, 0, 0, 0, 2477, 2478, 1, 0, 0, 0, 2478, 2480, 1, 0, 0, 0, 2479, 2477, 1, 0, 0, 0, 2480, 2482, 3, 110, 55, 0, 2481, 2470, 1, 0, 0, 0, 2482, 2485, 1, 0, 0, 0, 2483, 2481, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2493, 1, 0, 0, 0, 2485, 2483, 1, 0, 0, 0, 2486, 2488, 5, 5, 0, 0, 2487, 2486, 1, 0, 0, 0, 2488, 2491, 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2492, 1, 0, 0, 0, 2491, 2489, 1, 0, 0, 0, 2492, 2494, 5, 8, 0, 0, 2493, 2489, 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2498, 1, 0, 0, 0, 2495, 2497, 5, 5, 0, 0, 2496, 2495, 1, 0, 0, 0, 2497, 2500, 1, 0, 0, 0, 2498, 2496, 1, 0, 0, 0, 2498, 2499, 1, 0, 0, 0, 2499, 2501, 1, 0, 0, 0, 2500, 2498, 1, 0, 0, 0, 2501, 2502, 5, 47, 0, 0, 2502, 207, 1, 0, 0, 0, 2503, 2507, 5, 9, 0, 0, 2504, 2506, 5, 5, 0, 0, 2505, 2504, 1, 0, 0, 0, 2506, 2509, 1, 0, 0, 0, 2507, 2505, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2545, 1, 0, 0, 0, 2509, 2507, 1, 0, 0, 0, 2510, 2527, 3, 210, 105, 0, 2511, 2513, 5, 5, 0, 0, 2512, 2511, 1, 0, 0, 0, 2513, 2516, 1, 0, 0, 0, 2514, 2512, 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, 2517, 1, 0, 0, 0, 2516, 2514, 1, 0, 0, 0, 2517, 2521, 5, 8, 0, 0, 2518, 2520, 5, 5, 0, 0, 2519, 2518, 1, 0, 0, 0, 2520, 2523, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2521, 2522, 1, 0, 0, 0, 2522, 2524, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2524, 2526, 3, 210, 105, 0, 2525, 2514, 1, 0, 0, 0, 2526, 2529, 1, 0, 0, 0, 2527, 2525, 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2537, 1, 0, 0, 0, 2529, 2527, 1, 0, 0, 0, 2530, 2532, 5, 5, 0, 0, 2531, 2530, 1, 0, 0, 0, 2532, 2535, 1, 0, 0, 0, 2533, 2531, 1, 0, 0, 0, 2533, 2534, 1, 0, 0, 0, 2534, 2536, 1, 0, 0, 0, 2535, 2533, 1, 0, 0, 0, 2536, 2538, 5, 8, 0, 0, 2537, 2533, 1, 0, 0, 0, 2537, 2538, 1, 0, 0, 0, 2538, 2542, 1, 0, 0, 0, 2539, 2541, 5, 5, 0, 0, 2540, 2539, 1, 0, 0, 0, 2541, 2544, 1, 0, 0, 0, 2542, 2540, 1, 0, 0, 0, 2542, 2543, 1, 0, 0, 0, 2543, 2546, 1, 0, 0, 0, 2544, 2542, 1, 0, 0, 0, 2545, 2510, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2547, 1, 0, 0, 0, 2547, 2548, 5, 10, 0, 0, 2548, 209, 1, 0, 0, 0, 2549, 2551, 3, 334, 167, 0, 2550, 2549, 1, 0, 0, 0, 2550, 2551, 1, 0, 0, 0, 2551, 2555, 1, 0, 0, 0, 2552, 2554, 5, 5, 0, 0, 2553, 2552, 1, 0, 0, 0, 2554, 2557, 1, 0, 0, 0, 2555, 2553, 1, 0, 0, 0, 2555, 2556, 1, 0, 0, 0, 2556, 2572, 1, 0, 0, 0, 2557, 2555, 1, 0, 0, 0, 2558, 2562, 3, 344, 172, 0, 2559, 2561, 5, 5, 0, 0, 2560, 2559, 1, 0, 0, 0, 2561, 2564, 1, 0, 0, 0, 2562, 2560, 1, 0, 0, 0, 2562, 2563, 1, 0, 0, 0, 2563, 2565, 1, 0, 0, 0, 2564, 2562, 1, 0, 0, 0, 2565, 2569, 5, 28, 0, 0, 2566, 2568, 5, 5, 0, 0, 2567, 2566, 1, 0, 0, 0, 2568, 2571, 1, 0, 0, 0, 2569, 2567, 1, 0, 0, 0, 2569, 2570, 1, 0, 0, 0, 2570, 2573, 1, 0, 0, 0, 2571, 2569, 1, 0, 0, 0, 2572, 2558, 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2575, 1, 0, 0, 0, 2574, 2576, 5, 15, 0, 0, 2575, 2574, 1, 0, 0, 0, 2575, 2576, 1, 0, 0, 0, 2576, 2580, 1, 0, 0, 0, 2577, 2579, 5, 5, 0, 0, 2578, 2577, 1, 0, 0, 0, 2579, 2582, 1, 0, 0, 0, 2580, 2578, 1, 0, 0, 0, 2580, 2581, 1, 0, 0, 0, 2581, 2583, 1, 0, 0, 0, 2582, 2580, 1, 0, 0, 0, 2583, 2584, 3, 152, 76, 0, 2584, 211, 1, 0, 0, 0, 2585, 2600, 3, 214, 107, 0, 2586, 2600, 3, 344, 172, 0, 2587, 2600, 3, 218, 109, 0, 2588, 2600, 3, 220, 110, 0, 2589, 2600, 3, 272, 136, 0, 2590, 2600, 3, 242, 121, 0, 2591, 2600, 3, 244, 122, 0, 2592, 2600, 3, 216, 108, 0, 2593, 2600, 3, 246, 123, 0, 2594, 2600, 3, 248, 124, 0, 2595, 2600, 3, 250, 125, 0, 2596, 2600, 3, 254, 127, 0, 2597, 2600, 3, 264, 132, 0, 2598, 2600, 3, 270, 135, 0, 2599, 2585, 1, 0, 0, 0, 2599, 2586, 1, 0, 0, 0, 2599, 2587, 1, 0, 0, 0, 2599, 2588, 1, 0, 0, 0, 2599, 2589, 1, 0, 0, 0, 2599, 2590, 1, 0, 0, 0, 2599, 2591, 1, 0, 0, 0, 2599, 2592, 1, 0, 0, 0, 2599, 2593, 1, 0, 0, 0, 2599, 2594, 1, 0, 0, 0, 2599, 2595, 1, 0, 0, 0, 2599, 2596, 1, 0, 0, 0, 2599, 2597, 1, 0, 0, 0, 2599, 2598, 1, 0, 0, 0, 2600, 213, 1, 0, 0, 0, 2601, 2605, 5, 9, 0, 0, 2602, 2604, 5, 5, 0, 0, 2603, 2602, 1, 0, 0, 0, 2604, 2607, 1, 0, 0, 0, 2605, 2603, 1, 0, 0, 0, 2605, 2606, 1, 0, 0, 0, 2606, 2608, 1, 0, 0, 0, 2607, 2605, 1, 0, 0, 0, 2608, 2612, 3, 152, 76, 0, 2609, 2611, 5, 5, 0, 0, 2610, 2609, 1, 0, 0, 0, 2611, 2614, 1, 0, 0, 0, 2612, 2610, 1, 0, 0, 0, 2612, 2613, 1, 0, 0, 0, 2613, 2615, 1, 0, 0, 0, 2614, 2612, 1, 0, 0, 0, 2615, 2616, 5, 10, 0, 0, 2616, 215, 1, 0, 0, 0, 2617, 2621, 5, 11, 0, 0, 2618, 2620, 5, 5, 0, 0, 2619, 2618, 1, 0, 0, 0, 2620, 2623, 1, 0, 0, 0, 2621, 2619, 1, 0, 0, 0, 2621, 2622, 1, 0, 0, 0, 2622, 2659, 1, 0, 0, 0, 2623, 2621, 1, 0, 0, 0, 2624, 2641, 3, 152, 76, 0, 2625, 2627, 5, 5, 0, 0, 2626, 2625, 1, 0, 0, 0, 2627, 2630, 1, 0, 0, 0, 2628, 2626, 1, 0, 0, 0, 2628, 2629, 1, 0, 0, 0, 2629, 2631, 1, 0, 0, 0, 2630, 2628, 1, 0, 0, 0, 2631, 2635, 5, 8, 0, 0, 2632, 2634, 5, 5, 0, 0, 2633, 2632, 1, 0, 0, 0, 2634, 2637, 1, 0, 0, 0, 2635, 2633, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2638, 1, 0, 0, 0, 2637, 2635, 1, 0, 0, 0, 2638, 2640, 3, 152, 76, 0, 2639, 2628, 1, 0, 0, 0, 2640, 2643, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2641, 2642, 1, 0, 0, 0, 2642, 2651, 1, 0, 0, 0, 2643, 2641, 1, 0, 0, 0, 2644, 2646, 5, 5, 0, 0, 2645, 2644, 1, 0, 0, 0, 2646, 2649, 1, 0, 0, 0, 2647, 2645, 1, 0, 0, 0, 2647, 2648, 1, 0, 0, 0, 2648, 2650, 1, 0, 0, 0, 2649, 2647, 1, 0, 0, 0, 2650, 2652, 5, 8, 0, 0, 2651, 2647, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 2656, 1, 0, 0, 0, 2653, 2655, 5, 5, 0, 0, 2654, 2653, 1, 0, 0, 0, 2655, 2658, 1, 0, 0, 0, 2656, 2654, 1, 0, 0, 0, 2656, 2657, 1, 0, 0, 0, 2657, 2660, 1, 0, 0, 0, 2658, 2656, 1, 0, 0, 0, 2659, 2624, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2661, 1, 0, 0, 0, 2661, 2662, 5, 12, 0, 0, 2662, 217, 1, 0, 0, 0, 2663, 2664, 7, 6, 0, 0, 2664, 219, 1, 0, 0, 0, 2665, 2668, 3, 222, 111, 0, 2666, 2668, 3, 224, 112, 0, 2667, 2665, 1, 0, 0, 0, 2667, 2666, 1, 0, 0, 0, 2668, 221, 1, 0, 0, 0, 2669, 2674, 5, 150, 0, 0, 2670, 2673, 3, 226, 113, 0, 2671, 2673, 3, 228, 114, 0, 2672, 2670, 1, 0, 0, 0, 2672, 2671, 1, 0, 0, 0, 2673, 2676, 1, 0, 0, 0, 2674, 2672, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 2677, 1, 0, 0, 0, 2676, 2674, 1, 0, 0, 0, 2677, 2678, 5, 159, 0, 0, 2678, 223, 1, 0, 0, 0, 2679, 2685, 5, 151, 0, 0, 2680, 2684, 3, 230, 115, 0, 2681, 2684, 3, 232, 116, 0, 2682, 2684, 5, 165, 0, 0, 2683, 2680, 1, 0, 0, 0, 2683, 2681, 1, 0, 0, 0, 2683, 2682, 1, 0, 0, 0, 2684, 2687, 1, 0, 0, 0, 2685, 2683, 1, 0, 0, 0, 2685, 2686, 1, 0, 0, 0, 2686, 2688, 1, 0, 0, 0, 2687, 2685, 1, 0, 0, 0, 2688, 2689, 5, 164, 0, 0, 2689, 225, 1, 0, 0, 0, 2690, 2691, 7, 7, 0, 0, 2691, 227, 1, 0, 0, 0, 2692, 2696, 5, 163, 0, 0, 2693, 2695, 5, 5, 0, 0, 2694, 2693, 1, 0, 0, 0, 2695, 2698, 1, 0, 0, 0, 2696, 2694, 1, 0, 0, 0, 2696, 2697, 1, 0, 0, 0, 2697, 2699, 1, 0, 0, 0, 2698, 2696, 1, 0, 0, 0, 2699, 2703, 3, 152, 76, 0, 2700, 2702, 5, 5, 0, 0, 2701, 2700, 1, 0, 0, 0, 2702, 2705, 1, 0, 0, 0, 2703, 2701, 1, 0, 0, 0, 2703, 2704, 1, 0, 0, 0, 2704, 2706, 1, 0, 0, 0, 2705, 2703, 1, 0, 0, 0, 2706, 2707, 5, 14, 0, 0, 2707, 229, 1, 0, 0, 0, 2708, 2709, 7, 8, 0, 0, 2709, 231, 1, 0, 0, 0, 2710, 2714, 5, 168, 0, 0, 2711, 2713, 5, 5, 0, 0, 2712, 2711, 1, 0, 0, 0, 2713, 2716, 1, 0, 0, 0, 2714, 2712, 1, 0, 0, 0, 2714, 2715, 1, 0, 0, 0, 2715, 2717, 1, 0, 0, 0, 2716, 2714, 1, 0, 0, 0, 2717, 2721, 3, 152, 76, 0, 2718, 2720, 5, 5, 0, 0, 2719, 2718, 1, 0, 0, 0, 2720, 2723, 1, 0, 0, 0, 2721, 2719, 1, 0, 0, 0, 2721, 2722, 1, 0, 0, 0, 2722, 2724, 1, 0, 0, 0, 2723, 2721, 1, 0, 0, 0, 2724, 2725, 5, 14, 0, 0, 2725, 233, 1, 0, 0, 0, 2726, 2730, 5, 13, 0, 0, 2727, 2729, 5, 5, 0, 0, 2728, 2727, 1, 0, 0, 0, 2729, 2732, 1, 0, 0, 0, 2730, 2728, 1, 0, 0, 0, 2730, 2731, 1, 0, 0, 0, 2731, 2749, 1, 0, 0, 0, 2732, 2730, 1, 0, 0, 0, 2733, 2735, 3, 236, 118, 0, 2734, 2733, 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, 2739, 1, 0, 0, 0, 2736, 2738, 5, 5, 0, 0, 2737, 2736, 1, 0, 0, 0, 2738, 2741, 1, 0, 0, 0, 2739, 2737, 1, 0, 0, 0, 2739, 2740, 1, 0, 0, 0, 2740, 2742, 1, 0, 0, 0, 2741, 2739, 1, 0, 0, 0, 2742, 2746, 5, 34, 0, 0, 2743, 2745, 5, 5, 0, 0, 2744, 2743, 1, 0, 0, 0, 2745, 2748, 1, 0, 0, 0, 2746, 2744, 1, 0, 0, 0, 2746, 2747, 1, 0, 0, 0, 2747, 2750, 1, 0, 0, 0, 2748, 2746, 1, 0, 0, 0, 2749, 2734, 1, 0, 0, 0, 2749, 2750, 1, 0, 0, 0, 2750, 2751, 1, 0, 0, 0, 2751, 2755, 3, 128, 64, 0, 2752, 2754, 5, 5, 0, 0, 2753, 2752, 1, 0, 0, 0, 2754, 2757, 1, 0, 0, 0, 2755, 2753, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2758, 1, 0, 0, 0, 2757, 2755, 1, 0, 0, 0, 2758, 2759, 5, 14, 0, 0, 2759, 235, 1, 0, 0, 0, 2760, 2777, 3, 238, 119, 0, 2761, 2763, 5, 5, 0, 0, 2762, 2761, 1, 0, 0, 0, 2763, 2766, 1, 0, 0, 0, 2764, 2762, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 2767, 1, 0, 0, 0, 2766, 2764, 1, 0, 0, 0, 2767, 2771, 5, 8, 0, 0, 2768, 2770, 5, 5, 0, 0, 2769, 2768, 1, 0, 0, 0, 2770, 2773, 1, 0, 0, 0, 2771, 2769, 1, 0, 0, 0, 2771, 2772, 1, 0, 0, 0, 2772, 2774, 1, 0, 0, 0, 2773, 2771, 1, 0, 0, 0, 2774, 2776, 3, 238, 119, 0, 2775, 2764, 1, 0, 0, 0, 2776, 2779, 1, 0, 0, 0, 2777, 2775, 1, 0, 0, 0, 2777, 2778, 1, 0, 0, 0, 2778, 2787, 1, 0, 0, 0, 2779, 2777, 1, 0, 0, 0, 2780, 2782, 5, 5, 0, 0, 2781, 2780, 1, 0, 0, 0, 2782, 2785, 1, 0, 0, 0, 2783, 2781, 1, 0, 0, 0, 2783, 2784, 1, 0, 0, 0, 2784, 2786, 1, 0, 0, 0, 2785, 2783, 1, 0, 0, 0, 2786, 2788, 5, 8, 0, 0, 2787, 2783, 1, 0, 0, 0, 2787, 2788, 1, 0, 0, 0, 2788, 237, 1, 0, 0, 0, 2789, 2808, 3, 66, 33, 0, 2790, 2805, 3, 68, 34, 0, 2791, 2793, 5, 5, 0, 0, 2792, 2791, 1, 0, 0, 0, 2793, 2796, 1, 0, 0, 0, 2794, 2792, 1, 0, 0, 0, 2794, 2795, 1, 0, 0, 0, 2795, 2797, 1, 0, 0, 0, 2796, 2794, 1, 0, 0, 0, 2797, 2801, 5, 26, 0, 0, 2798, 2800, 5, 5, 0, 0, 2799, 2798, 1, 0, 0, 0, 2800, 2803, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2801, 2802, 1, 0, 0, 0, 2802, 2804, 1, 0, 0, 0, 2803, 2801, 1, 0, 0, 0, 2804, 2806, 3, 98, 49, 0, 2805, 2794, 1, 0, 0, 0, 2805, 2806, 1, 0, 0, 0, 2806, 2808, 1, 0, 0, 0, 2807, 2789, 1, 0, 0, 0, 2807, 2790, 1, 0, 0, 0, 2808, 239, 1, 0, 0, 0, 2809, 2825, 5, 75, 0, 0, 2810, 2812, 5, 5, 0, 0, 2811, 2810, 1, 0, 0, 0, 2812, 2815, 1, 0, 0, 0, 2813, 2811, 1, 0, 0, 0, 2813, 2814, 1, 0, 0, 0, 2814, 2816, 1, 0, 0, 0, 2815, 2813, 1, 0, 0, 0, 2816, 2820, 3, 98, 49, 0, 2817, 2819, 5, 5, 0, 0, 2818, 2817, 1, 0, 0, 0, 2819, 2822, 1, 0, 0, 0, 2820, 2818, 1, 0, 0, 0, 2820, 2821, 1, 0, 0, 0, 2821, 2823, 1, 0, 0, 0, 2822, 2820, 1, 0, 0, 0, 2823, 2824, 5, 7, 0, 0, 2824, 2826, 1, 0, 0, 0, 2825, 2813, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2830, 1, 0, 0, 0, 2827, 2829, 5, 5, 0, 0, 2828, 2827, 1, 0, 0, 0, 2829, 2832, 1, 0, 0, 0, 2830, 2828, 1, 0, 0, 0, 2830, 2831, 1, 0, 0, 0, 2831, 2833, 1, 0, 0, 0, 2832, 2830, 1, 0, 0, 0, 2833, 2848, 3, 78, 39, 0, 2834, 2836, 5, 5, 0, 0, 2835, 2834, 1, 0, 0, 0, 2836, 2839, 1, 0, 0, 0, 2837, 2835, 1, 0, 0, 0, 2837, 2838, 1, 0, 0, 0, 2838, 2840, 1, 0, 0, 0, 2839, 2837, 1, 0, 0, 0, 2840, 2844, 5, 26, 0, 0, 2841, 2843, 5, 5, 0, 0, 2842, 2841, 1, 0, 0, 0, 2843, 2846, 1, 0, 0, 0, 2844, 2842, 1, 0, 0, 0, 2844, 2845, 1, 0, 0, 0, 2845, 2847, 1, 0, 0, 0, 2846, 2844, 1, 0, 0, 0, 2847, 2849, 3, 98, 49, 0, 2848, 2837, 1, 0, 0, 0, 2848, 2849, 1, 0, 0, 0, 2849, 2857, 1, 0, 0, 0, 2850, 2852, 5, 5, 0, 0, 2851, 2850, 1, 0, 0, 0, 2852, 2855, 1, 0, 0, 0, 2853, 2851, 1, 0, 0, 0, 2853, 2854, 1, 0, 0, 0, 2854, 2856, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2856, 2858, 3, 46, 23, 0, 2857, 2853, 1, 0, 0, 0, 2857, 2858, 1, 0, 0, 0, 2858, 2866, 1, 0, 0, 0, 2859, 2861, 5, 5, 0, 0, 2860, 2859, 1, 0, 0, 0, 2861, 2864, 1, 0, 0, 0, 2862, 2860, 1, 0, 0, 0, 2862, 2863, 1, 0, 0, 0, 2863, 2865, 1, 0, 0, 0, 2864, 2862, 1, 0, 0, 0, 2865, 2867, 3, 64, 32, 0, 2866, 2862, 1, 0, 0, 0, 2866, 2867, 1, 0, 0, 0, 2867, 241, 1, 0, 0, 0, 2868, 2871, 3, 234, 117, 0, 2869, 2871, 3, 240, 120, 0, 2870, 2868, 1, 0, 0, 0, 2870, 2869, 1, 0, 0, 0, 2871, 243, 1, 0, 0, 0, 2872, 2893, 5, 76, 0, 0, 2873, 2875, 5, 5, 0, 0, 2874, 2873, 1, 0, 0, 0, 2875, 2878, 1, 0, 0, 0, 2876, 2874, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, 2879, 1, 0, 0, 0, 2878, 2876, 1, 0, 0, 0, 2879, 2883, 5, 26, 0, 0, 2880, 2882, 5, 5, 0, 0, 2881, 2880, 1, 0, 0, 0, 2882, 2885, 1, 0, 0, 0, 2883, 2881, 1, 0, 0, 0, 2883, 2884, 1, 0, 0, 0, 2884, 2886, 1, 0, 0, 0, 2885, 2883, 1, 0, 0, 0, 2886, 2890, 3, 32, 16, 0, 2887, 2889, 5, 5, 0, 0, 2888, 2887, 1, 0, 0, 0, 2889, 2892, 1, 0, 0, 0, 2890, 2888, 1, 0, 0, 0, 2890, 2891, 1, 0, 0, 0, 2891, 2894, 1, 0, 0, 0, 2892, 2890, 1, 0, 0, 0, 2893, 2876, 1, 0, 0, 0, 2893, 2894, 1, 0, 0, 0, 2894, 2902, 1, 0, 0, 0, 2895, 2897, 5, 5, 0, 0, 2896, 2895, 1, 0, 0, 0, 2897, 2900, 1, 0, 0, 0, 2898, 2896, 1, 0, 0, 0, 2898, 2899, 1, 0, 0, 0, 2899, 2901, 1, 0, 0, 0, 2900, 2898, 1, 0, 0, 0, 2901, 2903, 3, 26, 13, 0, 2902, 2898, 1, 0, 0, 0, 2902, 2903, 1, 0, 0, 0, 2903, 245, 1, 0, 0, 0, 2904, 2905, 7, 9, 0, 0, 2905, 247, 1, 0, 0, 0, 2906, 2923, 5, 85, 0, 0, 2907, 2911, 5, 46, 0, 0, 2908, 2910, 5, 5, 0, 0, 2909, 2908, 1, 0, 0, 0, 2910, 2913, 1, 0, 0, 0, 2911, 2909, 1, 0, 0, 0, 2911, 2912, 1, 0, 0, 0, 2912, 2914, 1, 0, 0, 0, 2913, 2911, 1, 0, 0, 0, 2914, 2918, 3, 98, 49, 0, 2915, 2917, 5, 5, 0, 0, 2916, 2915, 1, 0, 0, 0, 2917, 2920, 1, 0, 0, 0, 2918, 2916, 1, 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 2921, 1, 0, 0, 0, 2920, 2918, 1, 0, 0, 0, 2921, 2922, 5, 47, 0, 0, 2922, 2924, 1, 0, 0, 0, 2923, 2907, 1, 0, 0, 0, 2923, 2924, 1, 0, 0, 0, 2924, 2927, 1, 0, 0, 0, 2925, 2926, 5, 40, 0, 0, 2926, 2928, 3, 344, 172, 0, 2927, 2925, 1, 0, 0, 0, 2927, 2928, 1, 0, 0, 0, 2928, 2931, 1, 0, 0, 0, 2929, 2931, 5, 61, 0, 0, 2930, 2906, 1, 0, 0, 0, 2930, 2929, 1, 0, 0, 0, 2931, 249, 1, 0, 0, 0, 2932, 2936, 5, 88, 0, 0, 2933, 2935, 5, 5, 0, 0, 2934, 2933, 1, 0, 0, 0, 2935, 2938, 1, 0, 0, 0, 2936, 2934, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 2939, 1, 0, 0, 0, 2938, 2936, 1, 0, 0, 0, 2939, 2943, 5, 9, 0, 0, 2940, 2942, 5, 5, 0, 0, 2941, 2940, 1, 0, 0, 0, 2942, 2945, 1, 0, 0, 0, 2943, 2941, 1, 0, 0, 0, 2943, 2944, 1, 0, 0, 0, 2944, 2946, 1, 0, 0, 0, 2945, 2943, 1, 0, 0, 0, 2946, 2950, 3, 152, 76, 0, 2947, 2949, 5, 5, 0, 0, 2948, 2947, 1, 0, 0, 0, 2949, 2952, 1, 0, 0, 0, 2950, 2948, 1, 0, 0, 0, 2950, 2951, 1, 0, 0, 0, 2951, 2953, 1, 0, 0, 0, 2952, 2950, 1, 0, 0, 0, 2953, 2957, 5, 10, 0, 0, 2954, 2956, 5, 5, 0, 0, 2955, 2954, 1, 0, 0, 0, 2956, 2959, 1, 0, 0, 0, 2957, 2955, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, 2991, 1, 0, 0, 0, 2959, 2957, 1, 0, 0, 0, 2960, 2992, 3, 134, 67, 0, 2961, 2963, 3, 134, 67, 0, 2962, 2961, 1, 0, 0, 0, 2962, 2963, 1, 0, 0, 0, 2963, 2967, 1, 0, 0, 0, 2964, 2966, 5, 5, 0, 0, 2965, 2964, 1, 0, 0, 0, 2966, 2969, 1, 0, 0, 0, 2967, 2965, 1, 0, 0, 0, 2967, 2968, 1, 0, 0, 0, 2968, 2971, 1, 0, 0, 0, 2969, 2967, 1, 0, 0, 0, 2970, 2972, 5, 27, 0, 0, 2971, 2970, 1, 0, 0, 0, 2971, 2972, 1, 0, 0, 0, 2972, 2976, 1, 0, 0, 0, 2973, 2975, 5, 5, 0, 0, 2974, 2973, 1, 0, 0, 0, 2975, 2978, 1, 0, 0, 0, 2976, 2974, 1, 0, 0, 0, 2976, 2977, 1, 0, 0, 0, 2977, 2979, 1, 0, 0, 0, 2978, 2976, 1, 0, 0, 0, 2979, 2983, 5, 89, 0, 0, 2980, 2982, 5, 5, 0, 0, 2981, 2980, 1, 0, 0, 0, 2982, 2985, 1, 0, 0, 0, 2983, 2981, 1, 0, 0, 0, 2983, 2984, 1, 0, 0, 0, 2984, 2988, 1, 0, 0, 0, 2985, 2983, 1, 0, 0, 0, 2986, 2989, 3, 134, 67, 0, 2987, 2989, 5, 27, 0, 0, 2988, 2986, 1, 0, 0, 0, 2988, 2987, 1, 0, 0, 0, 2989, 2992, 1, 0, 0, 0, 2990, 2992, 5, 27, 0, 0, 2991, 2960, 1, 0, 0, 0, 2991, 2962, 1, 0, 0, 0, 2991, 2990, 1, 0, 0, 0, 2992, 251, 1, 0, 0, 0, 2993, 3027, 5, 9, 0, 0, 2994, 2996, 3, 334, 167, 0, 2995, 2994, 1, 0, 0, 0, 2996, 2999, 1, 0, 0, 0, 2997, 2995, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, 3003, 1, 0, 0, 0, 2999, 2997, 1, 0, 0, 0, 3000, 3002, 5, 5, 0, 0, 3001, 3000, 1, 0, 0, 0, 3002, 3005, 1, 0, 0, 0, 3003, 3001, 1, 0, 0, 0, 3003, 3004, 1, 0, 0, 0, 3004, 3006, 1, 0, 0, 0, 3005, 3003, 1, 0, 0, 0, 3006, 3010, 5, 77, 0, 0, 3007, 3009, 5, 5, 0, 0, 3008, 3007, 1, 0, 0, 0, 3009, 3012, 1, 0, 0, 0, 3010, 3008, 1, 0, 0, 0, 3010, 3011, 1, 0, 0, 0, 3011, 3013, 1, 0, 0, 0, 3012, 3010, 1, 0, 0, 0, 3013, 3017, 3, 66, 33, 0, 3014, 3016, 5, 5, 0, 0, 3015, 3014, 1, 0, 0, 0, 3016, 3019, 1, 0, 0, 0, 3017, 3015, 1, 0, 0, 0, 3017, 3018, 1, 0, 0, 0, 3018, 3020, 1, 0, 0, 0, 3019, 3017, 1, 0, 0, 0, 3020, 3024, 5, 28, 0, 0, 3021, 3023, 5, 5, 0, 0, 3022, 3021, 1, 0, 0, 0, 3023, 3026, 1, 0, 0, 0, 3024, 3022, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3028, 1, 0, 0, 0, 3026, 3024, 1, 0, 0, 0, 3027, 2997, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, 3030, 3, 152, 76, 0, 3030, 3031, 5, 10, 0, 0, 3031, 253, 1, 0, 0, 0, 3032, 3036, 5, 90, 0, 0, 3033, 3035, 5, 5, 0, 0, 3034, 3033, 1, 0, 0, 0, 3035, 3038, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 3040, 1, 0, 0, 0, 3038, 3036, 1, 0, 0, 0, 3039, 3041, 3, 252, 126, 0, 3040, 3039, 1, 0, 0, 0, 3040, 3041, 1, 0, 0, 0, 3041, 3045, 1, 0, 0, 0, 3042, 3044, 5, 5, 0, 0, 3043, 3042, 1, 0, 0, 0, 3044, 3047, 1, 0, 0, 0, 3045, 3043, 1, 0, 0, 0, 3045, 3046, 1, 0, 0, 0, 3046, 3048, 1, 0, 0, 0, 3047, 3045, 1, 0, 0, 0, 3048, 3052, 5, 13, 0, 0, 3049, 3051, 5, 5, 0, 0, 3050, 3049, 1, 0, 0, 0, 3051, 3054, 1, 0, 0, 0, 3052, 3050, 1, 0, 0, 0, 3052, 3053, 1, 0, 0, 0, 3053, 3064, 1, 0, 0, 0, 3054, 3052, 1, 0, 0, 0, 3055, 3059, 3, 256, 128, 0, 3056, 3058, 5, 5, 0, 0, 3057, 3056, 1, 0, 0, 0, 3058, 3061, 1, 0, 0, 0, 3059, 3057, 1, 0, 0, 0, 3059, 3060, 1, 0, 0, 0, 3060, 3063, 1, 0, 0, 0, 3061, 3059, 1, 0, 0, 0, 3062, 3055, 1, 0, 0, 0, 3063, 3066, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3064, 3065, 1, 0, 0, 0, 3065, 3070, 1, 0, 0, 0, 3066, 3064, 1, 0, 0, 0, 3067, 3069, 5, 5, 0, 0, 3068, 3067, 1, 0, 0, 0, 3069, 3072, 1, 0, 0, 0, 3070, 3068, 1, 0, 0, 0, 3070, 3071, 1, 0, 0, 0, 3071, 3073, 1, 0, 0, 0, 3072, 3070, 1, 0, 0, 0, 3073, 3074, 5, 14, 0, 0, 3074, 255, 1, 0, 0, 0, 3075, 3092, 3, 258, 129, 0, 3076, 3078, 5, 5, 0, 0, 3077, 3076, 1, 0, 0, 0, 3078, 3081, 1, 0, 0, 0, 3079, 3077, 1, 0, 0, 0, 3079, 3080, 1, 0, 0, 0, 3080, 3082, 1, 0, 0, 0, 3081, 3079, 1, 0, 0, 0, 3082, 3086, 5, 8, 0, 0, 3083, 3085, 5, 5, 0, 0, 3084, 3083, 1, 0, 0, 0, 3085, 3088, 1, 0, 0, 0, 3086, 3084, 1, 0, 0, 0, 3086, 3087, 1, 0, 0, 0, 3087, 3089, 1, 0, 0, 0, 3088, 3086, 1, 0, 0, 0, 3089, 3091, 3, 258, 129, 0, 3090, 3079, 1, 0, 0, 0, 3091, 3094, 1, 0, 0, 0, 3092, 3090, 1, 0, 0, 0, 3092, 3093, 1, 0, 0, 0, 3093, 3102, 1, 0, 0, 0, 3094, 3092, 1, 0, 0, 0, 3095, 3097, 5, 5, 0, 0, 3096, 3095, 1, 0, 0, 0, 3097, 3100, 1, 0, 0, 0, 3098, 3096, 1, 0, 0, 0, 3098, 3099, 1, 0, 0, 0, 3099, 3101, 1, 0, 0, 0, 3100, 3098, 1, 0, 0, 0, 3101, 3103, 5, 8, 0, 0, 3102, 3098, 1, 0, 0, 0, 3102, 3103, 1, 0, 0, 0, 3103, 3107, 1, 0, 0, 0, 3104, 3106, 5, 5, 0, 0, 3105, 3104, 1, 0, 0, 0, 3106, 3109, 1, 0, 0, 0, 3107, 3105, 1, 0, 0, 0, 3107, 3108, 1, 0, 0, 0, 3108, 3110, 1, 0, 0, 0, 3109, 3107, 1, 0, 0, 0, 3110, 3114, 5, 34, 0, 0, 3111, 3113, 5, 5, 0, 0, 3112, 3111, 1, 0, 0, 0, 3113, 3116, 1, 0, 0, 0, 3114, 3112, 1, 0, 0, 0, 3114, 3115, 1, 0, 0, 0, 3115, 3117, 1, 0, 0, 0, 3116, 3114, 1, 0, 0, 0, 3117, 3119, 3, 134, 67, 0, 3118, 3120, 3, 148, 74, 0, 3119, 3118, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 3140, 1, 0, 0, 0, 3121, 3125, 5, 89, 0, 0, 3122, 3124, 5, 5, 0, 0, 3123, 3122, 1, 0, 0, 0, 3124, 3127, 1, 0, 0, 0, 3125, 3123, 1, 0, 0, 0, 3125, 3126, 1, 0, 0, 0, 3126, 3128, 1, 0, 0, 0, 3127, 3125, 1, 0, 0, 0, 3128, 3132, 5, 34, 0, 0, 3129, 3131, 5, 5, 0, 0, 3130, 3129, 1, 0, 0, 0, 3131, 3134, 1, 0, 0, 0, 3132, 3130, 1, 0, 0, 0, 3132, 3133, 1, 0, 0, 0, 3133, 3135, 1, 0, 0, 0, 3134, 3132, 1, 0, 0, 0, 3135, 3137, 3, 134, 67, 0, 3136, 3138, 3, 148, 74, 0, 3137, 3136, 1, 0, 0, 0, 3137, 3138, 1, 0, 0, 0, 3138, 3140, 1, 0, 0, 0, 3139, 3075, 1, 0, 0, 0, 3139, 3121, 1, 0, 0, 0, 3140, 257, 1, 0, 0, 0, 3141, 3145, 3, 152, 76, 0, 3142, 3145, 3, 260, 130, 0, 3143, 3145, 3, 262, 131, 0, 3144, 3141, 1, 0, 0, 0, 3144, 3142, 1, 0, 0, 0, 3144, 3143, 1, 0, 0, 0, 3145, 259, 1, 0, 0, 0, 3146, 3150, 3, 280, 140, 0, 3147, 3149, 5, 5, 0, 0, 3148, 3147, 1, 0, 0, 0, 3149, 3152, 1, 0, 0, 0, 3150, 3148, 1, 0, 0, 0, 3150, 3151, 1, 0, 0, 0, 3151, 3153, 1, 0, 0, 0, 3152, 3150, 1, 0, 0, 0, 3153, 3154, 3, 152, 76, 0, 3154, 261, 1, 0, 0, 0, 3155, 3159, 3, 282, 141, 0, 3156, 3158, 5, 5, 0, 0, 3157, 3156, 1, 0, 0, 0, 3158, 3161, 1, 0, 0, 0, 3159, 3157, 1, 0, 0, 0, 3159, 3160, 1, 0, 0, 0, 3160, 3162, 1, 0, 0, 0, 3161, 3159, 1, 0, 0, 0, 3162, 3163, 3, 98, 49, 0, 3163, 263, 1, 0, 0, 0, 3164, 3168, 5, 91, 0, 0, 3165, 3167, 5, 5, 0, 0, 3166, 3165, 1, 0, 0, 0, 3167, 3170, 1, 0, 0, 0, 3168, 3166, 1, 0, 0, 0, 3168, 3169, 1, 0, 0, 0, 3169, 3171, 1, 0, 0, 0, 3170, 3168, 1, 0, 0, 0, 3171, 3199, 3, 136, 68, 0, 3172, 3174, 5, 5, 0, 0, 3173, 3172, 1, 0, 0, 0, 3174, 3177, 1, 0, 0, 0, 3175, 3173, 1, 0, 0, 0, 3175, 3176, 1, 0, 0, 0, 3176, 3178, 1, 0, 0, 0, 3177, 3175, 1, 0, 0, 0, 3178, 3180, 3, 266, 133, 0, 3179, 3175, 1, 0, 0, 0, 3180, 3181, 1, 0, 0, 0, 3181, 3179, 1, 0, 0, 0, 3181, 3182, 1, 0, 0, 0, 3182, 3190, 1, 0, 0, 0, 3183, 3185, 5, 5, 0, 0, 3184, 3183, 1, 0, 0, 0, 3185, 3188, 1, 0, 0, 0, 3186, 3184, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3189, 1, 0, 0, 0, 3188, 3186, 1, 0, 0, 0, 3189, 3191, 3, 268, 134, 0, 3190, 3186, 1, 0, 0, 0, 3190, 3191, 1, 0, 0, 0, 3191, 3200, 1, 0, 0, 0, 3192, 3194, 5, 5, 0, 0, 3193, 3192, 1, 0, 0, 0, 3194, 3197, 1, 0, 0, 0, 3195, 3193, 1, 0, 0, 0, 3195, 3196, 1, 0, 0, 0, 3196, 3198, 1, 0, 0, 0, 3197, 3195, 1, 0, 0, 0, 3198, 3200, 3, 268, 134, 0, 3199, 3179, 1, 0, 0, 0, 3199, 3195, 1, 0, 0, 0, 3200, 265, 1, 0, 0, 0, 3201, 3205, 5, 92, 0, 0, 3202, 3204, 5, 5, 0, 0, 3203, 3202, 1, 0, 0, 0, 3204, 3207, 1, 0, 0, 0, 3205, 3203, 1, 0, 0, 0, 3205, 3206, 1, 0, 0, 0, 3206, 3208, 1, 0, 0, 0, 3207, 3205, 1, 0, 0, 0, 3208, 3212, 5, 9, 0, 0, 3209, 3211, 3, 334, 167, 0, 3210, 3209, 1, 0, 0, 0, 3211, 3214, 1, 0, 0, 0, 3212, 3210, 1, 0, 0, 0, 3212, 3213, 1, 0, 0, 0, 3213, 3215, 1, 0, 0, 0, 3214, 3212, 1, 0, 0, 0, 3215, 3216, 3, 344, 172, 0, 3216, 3217, 5, 26, 0, 0, 3217, 3225, 3, 98, 49, 0, 3218, 3220, 5, 5, 0, 0, 3219, 3218, 1, 0, 0, 0, 3220, 3223, 1, 0, 0, 0, 3221, 3219, 1, 0, 0, 0, 3221, 3222, 1, 0, 0, 0, 3222, 3224, 1, 0, 0, 0, 3223, 3221, 1, 0, 0, 0, 3224, 3226, 5, 8, 0, 0, 3225, 3221, 1, 0, 0, 0, 3225, 3226, 1, 0, 0, 0, 3226, 3227, 1, 0, 0, 0, 3227, 3231, 5, 10, 0, 0, 3228, 3230, 5, 5, 0, 0, 3229, 3228, 1, 0, 0, 0, 3230, 3233, 1, 0, 0, 0, 3231, 3229, 1, 0, 0, 0, 3231, 3232, 1, 0, 0, 0, 3232, 3234, 1, 0, 0, 0, 3233, 3231, 1, 0, 0, 0, 3234, 3235, 3, 136, 68, 0, 3235, 267, 1, 0, 0, 0, 3236, 3240, 5, 93, 0, 0, 3237, 3239, 5, 5, 0, 0, 3238, 3237, 1, 0, 0, 0, 3239, 3242, 1, 0, 0, 0, 3240, 3238, 1, 0, 0, 0, 3240, 3241, 1, 0, 0, 0, 3241, 3243, 1, 0, 0, 0, 3242, 3240, 1, 0, 0, 0, 3243, 3244, 3, 136, 68, 0, 3244, 269, 1, 0, 0, 0, 3245, 3249, 5, 97, 0, 0, 3246, 3248, 5, 5, 0, 0, 3247, 3246, 1, 0, 0, 0, 3248, 3251, 1, 0, 0, 0, 3249, 3247, 1, 0, 0, 0, 3249, 3250, 1, 0, 0, 0, 3250, 3252, 1, 0, 0, 0, 3251, 3249, 1, 0, 0, 0, 3252, 3262, 3, 152, 76, 0, 3253, 3255, 7, 10, 0, 0, 3254, 3256, 3, 152, 76, 0, 3255, 3254, 1, 0, 0, 0, 3255, 3256, 1, 0, 0, 0, 3256, 3262, 1, 0, 0, 0, 3257, 3262, 5, 99, 0, 0, 3258, 3262, 5, 58, 0, 0, 3259, 3262, 5, 100, 0, 0, 3260, 3262, 5, 59, 0, 0, 3261, 3245, 1, 0, 0, 0, 3261, 3253, 1, 0, 0, 0, 3261, 3257, 1, 0, 0, 0, 3261, 3258, 1, 0, 0, 0, 3261, 3259, 1, 0, 0, 0, 3261, 3260, 1, 0, 0, 0, 3262, 271, 1, 0, 0, 0, 3263, 3265, 3, 122, 61, 0, 3264, 3263, 1, 0, 0, 0, 3264, 3265, 1, 0, 0, 0, 3265, 3266, 1, 0, 0, 0, 3266, 3270, 5, 37, 0, 0, 3267, 3269, 5, 5, 0, 0, 3268, 3267, 1, 0, 0, 0, 3269, 3272, 1, 0, 0, 0, 3270, 3268, 1, 0, 0, 0, 3270, 3271, 1, 0, 0, 0, 3271, 3275, 1, 0, 0, 0, 3272, 3270, 1, 0, 0, 0, 3273, 3276, 3, 344, 172, 0, 3274, 3276, 5, 73, 0, 0, 3275, 3273, 1, 0, 0, 0, 3275, 3274, 1, 0, 0, 0, 3276, 273, 1, 0, 0, 0, 3277, 3278, 7, 11, 0, 0, 3278, 275, 1, 0, 0, 0, 3279, 3280, 7, 12, 0, 0, 3280, 277, 1, 0, 0, 0, 3281, 3282, 7, 13, 0, 0, 3282, 279, 1, 0, 0, 0, 3283, 3284, 7, 14, 0, 0, 3284, 281, 1, 0, 0, 0, 3285, 3286, 7, 15, 0, 0, 3286, 283, 1, 0, 0, 0, 3287, 3288, 7, 16, 0, 0, 3288, 285, 1, 0, 0, 0, 3289, 3290, 7, 17, 0, 0, 3290, 287, 1, 0, 0, 0, 3291, 3292, 7, 18, 0, 0, 3292, 289, 1, 0, 0, 0, 3293, 3299, 5, 20, 0, 0, 3294, 3299, 5, 21, 0, 0, 3295, 3299, 5, 19, 0, 0, 3296, 3299, 5, 18, 0, 0, 3297, 3299, 3, 294, 147, 0, 3298, 3293, 1, 0, 0, 0, 3298, 3294, 1, 0, 0, 0, 3298, 3295, 1, 0, 0, 0, 3298, 3296, 1, 0, 0, 0, 3298, 3297, 1, 0, 0, 0, 3299, 291, 1, 0, 0, 0, 3300, 3305, 5, 20, 0, 0, 3301, 3305, 5, 21, 0, 0, 3302, 3303, 5, 25, 0, 0, 3303, 3305, 3, 294, 147, 0, 3304, 3300, 1, 0, 0, 0, 3304, 3301, 1, 0, 0, 0, 3304, 3302, 1, 0, 0, 0, 3305, 293, 1, 0, 0, 0, 3306, 3307, 7, 19, 0, 0, 3307, 295, 1, 0, 0, 0, 3308, 3310, 5, 5, 0, 0, 3309, 3308, 1, 0, 0, 0, 3310, 3313, 1, 0, 0, 0, 3311, 3309, 1, 0, 0, 0, 3311, 3312, 1, 0, 0, 0, 3312, 3314, 1, 0, 0, 0, 3313, 3311, 1, 0, 0, 0, 3314, 3324, 5, 7, 0, 0, 3315, 3317, 5, 5, 0, 0, 3316, 3315, 1, 0, 0, 0, 3317, 3320, 1, 0, 0, 0, 3318, 3316, 1, 0, 0, 0, 3318, 3319, 1, 0, 0, 0, 3319, 3321, 1, 0, 0, 0, 3320, 3318, 1, 0, 0, 0, 3321, 3324, 3, 298, 149, 0, 3322, 3324, 5, 37, 0, 0, 3323, 3311, 1, 0, 0, 0, 3323, 3318, 1, 0, 0, 0, 3323, 3322, 1, 0, 0, 0, 3324, 297, 1, 0, 0, 0, 3325, 3326, 5, 45, 0, 0, 3326, 3327, 5, 7, 0, 0, 3327, 299, 1, 0, 0, 0, 3328, 3331, 3, 334, 167, 0, 3329, 3331, 3, 304, 152, 0, 3330, 3328, 1, 0, 0, 0, 3330, 3329, 1, 0, 0, 0, 3331, 3332, 1, 0, 0, 0, 3332, 3330, 1, 0, 0, 0, 3332, 3333, 1, 0, 0, 0, 3333, 301, 1, 0, 0, 0, 3334, 3337, 3, 334, 167, 0, 3335, 3337, 3, 328, 164, 0, 3336, 3334, 1, 0, 0, 0, 3336, 3335, 1, 0, 0, 0, 3337, 3338, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3338, 3339, 1, 0, 0, 0, 3339, 303, 1, 0, 0, 0, 3340, 3349, 3, 310, 155, 0, 3341, 3349, 3, 312, 156, 0, 3342, 3349, 3, 314, 157, 0, 3343, 3349, 3, 322, 161, 0, 3344, 3349, 3, 324, 162, 0, 3345, 3349, 3, 326, 163, 0, 3346, 3349, 3, 328, 164, 0, 3347, 3349, 3, 332, 166, 0, 3348, 3340, 1, 0, 0, 0, 3348, 3341, 1, 0, 0, 0, 3348, 3342, 1, 0, 0, 0, 3348, 3343, 1, 0, 0, 0, 3348, 3344, 1, 0, 0, 0, 3348, 3345, 1, 0, 0, 0, 3348, 3346, 1, 0, 0, 0, 3348, 3347, 1, 0, 0, 0, 3349, 3353, 1, 0, 0, 0, 3350, 3352, 5, 5, 0, 0, 3351, 3350, 1, 0, 0, 0, 3352, 3355, 1, 0, 0, 0, 3353, 3351, 1, 0, 0, 0, 3353, 3354, 1, 0, 0, 0, 3354, 305, 1, 0, 0, 0, 3355, 3353, 1, 0, 0, 0, 3356, 3358, 3, 308, 154, 0, 3357, 3356, 1, 0, 0, 0, 3358, 3359, 1, 0, 0, 0, 3359, 3357, 1, 0, 0, 0, 3359, 3360, 1, 0, 0, 0, 3360, 307, 1, 0, 0, 0, 3361, 3370, 3, 334, 167, 0, 3362, 3366, 5, 123, 0, 0, 3363, 3365, 5, 5, 0, 0, 3364, 3363, 1, 0, 0, 0, 3365, 3368, 1, 0, 0, 0, 3366, 3364, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3370, 1, 0, 0, 0, 3368, 3366, 1, 0, 0, 0, 3369, 3361, 1, 0, 0, 0, 3369, 3362, 1, 0, 0, 0, 3370, 309, 1, 0, 0, 0, 3371, 3372, 7, 20, 0, 0, 3372, 311, 1, 0, 0, 0, 3373, 3374, 7, 21, 0, 0, 3374, 313, 1, 0, 0, 0, 3375, 3376, 7, 22, 0, 0, 3376, 315, 1, 0, 0, 0, 3377, 3378, 7, 23, 0, 0, 3378, 317, 1, 0, 0, 0, 3379, 3381, 3, 320, 160, 0, 3380, 3379, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 3380, 1, 0, 0, 0, 3382, 3383, 1, 0, 0, 0, 3383, 319, 1, 0, 0, 0, 3384, 3388, 3, 330, 165, 0, 3385, 3387, 5, 5, 0, 0, 3386, 3385, 1, 0, 0, 0, 3387, 3390, 1, 0, 0, 0, 3388, 3386, 1, 0, 0, 0, 3388, 3389, 1, 0, 0, 0, 3389, 3400, 1, 0, 0, 0, 3390, 3388, 1, 0, 0, 0, 3391, 3395, 3, 316, 158, 0, 3392, 3394, 5, 5, 0, 0, 3393, 3392, 1, 0, 0, 0, 3394, 3397, 1, 0, 0, 0, 3395, 3393, 1, 0, 0, 0, 3395, 3396, 1, 0, 0, 0, 3396, 3400, 1, 0, 0, 0, 3397, 3395, 1, 0, 0, 0, 3398, 3400, 3, 334, 167, 0, 3399, 3384, 1, 0, 0, 0, 3399, 3391, 1, 0, 0, 0, 3399, 3398, 1, 0, 0, 0, 3400, 321, 1, 0, 0, 0, 3401, 3402, 7, 24, 0, 0, 3402, 323, 1, 0, 0, 0, 3403, 3404, 5, 128, 0, 0, 3404, 325, 1, 0, 0, 0, 3405, 3406, 7, 25, 0, 0, 3406, 327, 1, 0, 0, 0, 3407, 3408, 7, 26, 0, 0, 3408, 329, 1, 0, 0, 0, 3409, 3410, 5, 133, 0, 0, 3410, 331, 1, 0, 0, 0, 3411, 3412, 7, 27, 0, 0, 3412, 333, 1, 0, 0, 0, 3413, 3416, 3, 336, 168, 0, 3414, 3416, 3, 338, 169, 0, 3415, 3413, 1, 0, 0, 0, 3415, 3414, 1, 0, 0, 0, 3416, 3420, 1, 0, 0, 0, 3417, 3419, 5, 5, 0, 0, 3418, 3417, 1, 0, 0, 0, 3419, 3422, 1, 0, 0, 0, 3420, 3418, 1, 0, 0, 0, 3420, 3421, 1, 0, 0, 0, 3421, 335, 1, 0, 0, 0, 3422, 3420, 1, 0, 0, 0, 3423, 3427, 3, 340, 170, 0, 3424, 3426, 5, 5, 0, 0, 3425, 3424, 1, 0, 0, 0, 3426, 3429, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3427, 3428, 1, 0, 0, 0, 3428, 3433, 1, 0, 0, 0, 3429, 3427, 1, 0, 0, 0, 3430, 3433, 5, 40, 0, 0, 3431, 3433, 5, 42, 0, 0, 3432, 3423, 1, 0, 0, 0, 3432, 3430, 1, 0, 0, 0, 3432, 3431, 1, 0, 0, 0, 3433, 3434, 1, 0, 0, 0, 3434, 3435, 3, 342, 171, 0, 3435, 337, 1, 0, 0, 0, 3436, 3440, 3, 340, 170, 0, 3437, 3439, 5, 5, 0, 0, 3438, 3437, 1, 0, 0, 0, 3439, 3442, 1, 0, 0, 0, 3440, 3438, 1, 0, 0, 0, 3440, 3441, 1, 0, 0, 0, 3441, 3446, 1, 0, 0, 0, 3442, 3440, 1, 0, 0, 0, 3443, 3446, 5, 40, 0, 0, 3444, 3446, 5, 42, 0, 0, 3445, 3436, 1, 0, 0, 0, 3445, 3443, 1, 0, 0, 0, 3445, 3444, 1, 0, 0, 0, 3446, 3447, 1, 0, 0, 0, 3447, 3449, 5, 11, 0, 0, 3448, 3450, 3, 342, 171, 0, 3449, 3448, 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451, 3449, 1, 0, 0, 0, 3451, 3452, 1, 0, 0, 0, 3452, 3453, 1, 0, 0, 0, 3453, 3454, 5, 12, 0, 0, 3454, 339, 1, 0, 0, 0, 3455, 3456, 7, 0, 0, 0, 3456, 3460, 7, 28, 0, 0, 3457, 3459, 5, 5, 0, 0, 3458, 3457, 1, 0, 0, 0, 3459, 3462, 1, 0, 0, 0, 3460, 3458, 1, 0, 0, 0, 3460, 3461, 1, 0, 0, 0, 3461, 3463, 1, 0, 0, 0, 3462, 3460, 1, 0, 0, 0, 3463, 3464, 5, 26, 0, 0, 3464, 341, 1, 0, 0, 0, 3465, 3468, 3, 36, 18, 0, 3466, 3468, 3, 106, 53, 0, 3467, 3465, 1, 0, 0, 0, 3467, 3466, 1, 0, 0, 0, 3468, 343, 1, 0, 0, 0, 3469, 3470, 7, 29, 0, 0, 3470, 345, 1, 0, 0, 0, 3471, 3482, 3, 344, 172, 0, 3472, 3474, 5, 5, 0, 0, 3473, 3472, 1, 0, 0, 0, 3474, 3477, 1, 0, 0, 0, 3475, 3473, 1, 0, 0, 0, 3475, 3476, 1, 0, 0, 0, 3476, 3478, 1, 0, 0, 0, 3477, 3475, 1, 0, 0, 0, 3478, 3479, 5, 7, 0, 0, 3479, 3481, 3, 344, 172, 0, 3480, 3475, 1, 0, 0, 0, 3481, 3484, 1, 0, 0, 0, 3482, 3480, 1, 0, 0, 0, 3482, 3483, 1, 0, 0, 0, 3483, 347, 1, 0, 0, 0, 3484, 3482, 1, 0, 0, 0, 535, 349, 354, 360, 368, 374, 379, 385, 395, 404, 411, 418, 425, 430, 435, 441, 443, 448, 456, 459, 466, 469, 475, 482, 486, 491, 498, 508, 511, 518, 521, 524, 529, 536, 540, 545, 549, 554, 561, 565, 570, 574, 579, 586, 590, 593, 599, 602, 610, 617, 626, 633, 640, 646, 652, 656, 658, 663, 669, 672, 677, 685, 692, 699, 703, 709, 716, 722, 733, 737, 745, 751, 758, 763, 770, 779, 786, 793, 799, 805, 809, 814, 820, 825, 832, 839, 843, 849, 856, 863, 869, 875, 882, 889, 896, 900, 907, 913, 919, 925, 932, 936, 941, 948, 952, 957, 961, 967, 974, 981, 987, 993, 997, 999, 1004, 1010, 1016, 1023, 1027, 1030, 1036, 1040, 1045, 1052, 1057, 1062, 1069, 1076, 1083, 1087, 1092, 1096, 1101, 1105, 1112, 1116, 1121, 1127, 1134, 1141, 1145, 1151, 1158, 1165, 1171, 1177, 1181, 1186, 1192, 1198, 1202, 1207, 1214, 1219, 1224, 1229, 1234, 1238, 1243, 1250, 1255, 1257, 1262, 1265, 1270, 1274, 1279, 1283, 1286, 1289, 1294, 1298, 1301, 1303, 1309, 1315, 1321, 1328, 1335, 1342, 1346, 1351, 1355, 1358, 1364, 1371, 1378, 1382, 1387, 1394, 1401, 1405, 1410, 1415, 1421, 1428, 1435, 1441, 1447, 1451, 1453, 1458, 1464, 1470, 1477, 1481, 1487, 1494, 1498, 1504, 1511, 1517, 1523, 1530, 1537, 1541, 1546, 1550, 1553, 1559, 1566, 1573, 1577, 1582, 1586, 1592, 1601, 1605, 1610, 1617, 1621, 1626, 1635, 1642, 1648, 1654, 1658, 1664, 1667, 1673, 1677, 1682, 1686, 1689, 1696, 1700, 1704, 1709, 1715, 1723, 1730, 1736, 1743, 1747, 1750, 1754, 1759, 1765, 1769, 1775, 1782, 1785, 1791, 1798, 1807, 1812, 1817, 1824, 1829, 1833, 1839, 1843, 1848, 1857, 1864, 1870, 1875, 1881, 1886, 1891, 1897, 1901, 1906, 1913, 1917, 1921, 1929, 1932, 1935, 1939, 1941, 1948, 1955, 1960, 1966, 1973, 1981, 1987, 1994, 1999, 2007, 2011, 2017, 2026, 2031, 2037, 2041, 2046, 2053, 2066, 2071, 2080, 2086, 2094, 2101, 2107, 2114, 2121, 2127, 2135, 2142, 2150, 2157, 2164, 2172, 2181, 2186, 2188, 2195, 2202, 2209, 2220, 2227, 2235, 2241, 2249, 2256, 2264, 2271, 2278, 2285, 2292, 2298, 2309, 2312, 2318, 2326, 2333, 2339, 2346, 2353, 2359, 2366, 2374, 2380, 2387, 2394, 2400, 2406, 2410, 2415, 2424, 2430, 2433, 2436, 2440, 2445, 2449, 2454, 2463, 2470, 2477, 2483, 2489, 2493, 2498, 2507, 2514, 2521, 2527, 2533, 2537, 2542, 2545, 2550, 2555, 2562, 2569, 2572, 2575, 2580, 2599, 2605, 2612, 2621, 2628, 2635, 2641, 2647, 2651, 2656, 2659, 2667, 2672, 2674, 2683, 2685, 2696, 2703, 2714, 2721, 2730, 2734, 2739, 2746, 2749, 2755, 2764, 2771, 2777, 2783, 2787, 2794, 2801, 2805, 2807, 2813, 2820, 2825, 2830, 2837, 2844, 2848, 2853, 2857, 2862, 2866, 2870, 2876, 2883, 2890, 2893, 2898, 2902, 2911, 2918, 2923, 2927, 2930, 2936, 2943, 2950, 2957, 2962, 2967, 2971, 2976, 2983, 2988, 2991, 2997, 3003, 3010, 3017, 3024, 3027, 3036, 3040, 3045, 3052, 3059, 3064, 3070, 3079, 3086, 3092, 3098, 3102, 3107, 3114, 3119, 3125, 3132, 3137, 3139, 3144, 3150, 3159, 3168, 3175, 3181, 3186, 3190, 3195, 3199, 3205, 3212, 3221, 3225, 3231, 3240, 3249, 3255, 3261, 3264, 3270, 3275, 3298, 3304, 3311, 3318, 3323, 3330, 3332, 3336, 3338, 3348, 3353, 3359, 3366, 3369, 3382, 3388, 3395, 3399, 3415, 3420, 3427, 3432, 3440, 3445, 3451, 3460, 3467, 3475, 3482] \ No newline at end of file diff --git a/lib/archer/kotlin_parser/KotlinParser.tokens b/lib/archer/kotlin_parser/KotlinParser.tokens new file mode 100644 index 0000000..8692c66 --- /dev/null +++ b/lib/archer/kotlin_parser/KotlinParser.tokens @@ -0,0 +1,292 @@ +ShebangLine=1 +DelimitedComment=2 +LineComment=3 +WS=4 +NL=5 +RESERVED=6 +DOT=7 +COMMA=8 +LPAREN=9 +RPAREN=10 +LSQUARE=11 +RSQUARE=12 +LCURL=13 +RCURL=14 +MULT=15 +MOD=16 +DIV=17 +ADD=18 +SUB=19 +INCR=20 +DECR=21 +CONJ=22 +DISJ=23 +EXCL_WS=24 +EXCL_NO_WS=25 +COLON=26 +SEMICOLON=27 +ASSIGNMENT=28 +ADD_ASSIGNMENT=29 +SUB_ASSIGNMENT=30 +MULT_ASSIGNMENT=31 +DIV_ASSIGNMENT=32 +MOD_ASSIGNMENT=33 +ARROW=34 +DOUBLE_ARROW=35 +RANGE=36 +COLONCOLON=37 +DOUBLE_SEMICOLON=38 +HASH=39 +AT_NO_WS=40 +AT_POST_WS=41 +AT_PRE_WS=42 +AT_BOTH_WS=43 +QUEST_WS=44 +QUEST_NO_WS=45 +LANGLE=46 +RANGLE=47 +LE=48 +GE=49 +EXCL_EQ=50 +EXCL_EQEQ=51 +AS_SAFE=52 +EQEQ=53 +EQEQEQ=54 +SINGLE_QUOTE=55 +AMP=56 +RETURN_AT=57 +CONTINUE_AT=58 +BREAK_AT=59 +THIS_AT=60 +SUPER_AT=61 +FILE=62 +FIELD=63 +PROPERTY=64 +GET=65 +SET=66 +RECEIVER=67 +PARAM=68 +SETPARAM=69 +DELEGATE=70 +PACKAGE=71 +IMPORT=72 +CLASS=73 +INTERFACE=74 +FUN=75 +OBJECT=76 +VAL=77 +VAR=78 +TYPE_ALIAS=79 +CONSTRUCTOR=80 +BY=81 +COMPANION=82 +INIT=83 +THIS=84 +SUPER=85 +TYPEOF=86 +WHERE=87 +IF=88 +ELSE=89 +WHEN=90 +TRY=91 +CATCH=92 +FINALLY=93 +FOR=94 +DO=95 +WHILE=96 +THROW=97 +RETURN=98 +CONTINUE=99 +BREAK=100 +AS=101 +IS=102 +IN=103 +NOT_IS=104 +NOT_IN=105 +OUT=106 +DYNAMIC=107 +PUBLIC=108 +PRIVATE=109 +PROTECTED=110 +INTERNAL=111 +ENUM=112 +SEALED=113 +ANNOTATION=114 +DATA=115 +INNER=116 +VALUE=117 +TAILREC=118 +OPERATOR=119 +INLINE=120 +INFIX=121 +EXTERNAL=122 +SUSPEND=123 +OVERRIDE=124 +ABSTRACT=125 +FINAL=126 +OPEN=127 +CONST=128 +LATEINIT=129 +VARARG=130 +NOINLINE=131 +CROSSINLINE=132 +REIFIED=133 +EXPECT=134 +ACTUAL=135 +RealLiteral=136 +FloatLiteral=137 +DoubleLiteral=138 +IntegerLiteral=139 +HexLiteral=140 +BinLiteral=141 +UnsignedLiteral=142 +LongLiteral=143 +BooleanLiteral=144 +NullLiteral=145 +CharacterLiteral=146 +Identifier=147 +IdentifierOrSoftKey=148 +FieldIdentifier=149 +QUOTE_OPEN=150 +TRIPLE_QUOTE_OPEN=151 +UNICODE_CLASS_LL=152 +UNICODE_CLASS_LM=153 +UNICODE_CLASS_LO=154 +UNICODE_CLASS_LT=155 +UNICODE_CLASS_LU=156 +UNICODE_CLASS_ND=157 +UNICODE_CLASS_NL=158 +QUOTE_CLOSE=159 +LineStrRef=160 +LineStrText=161 +LineStrEscapedChar=162 +LineStrExprStart=163 +TRIPLE_QUOTE_CLOSE=164 +MultiLineStringQuote=165 +MultiLineStrRef=166 +MultiLineStrText=167 +MultiLineStrExprStart=168 +Inside_Comment=169 +Inside_WS=170 +Inside_NL=171 +ErrorCharacter=172 +'...'=6 +'.'=7 +','=8 +'('=9 +')'=10 +'['=11 +']'=12 +'{'=13 +'}'=14 +'*'=15 +'%'=16 +'/'=17 +'+'=18 +'-'=19 +'++'=20 +'--'=21 +'&&'=22 +'||'=23 +'!'=25 +':'=26 +';'=27 +'='=28 +'+='=29 +'-='=30 +'*='=31 +'/='=32 +'%='=33 +'->'=34 +'=>'=35 +'..'=36 +'::'=37 +';;'=38 +'#'=39 +'@'=40 +'?'=45 +'<'=46 +'>'=47 +'<='=48 +'>='=49 +'!='=50 +'!=='=51 +'as?'=52 +'=='=53 +'==='=54 +'\''=55 +'&'=56 +'file'=62 +'field'=63 +'property'=64 +'get'=65 +'set'=66 +'receiver'=67 +'param'=68 +'setparam'=69 +'delegate'=70 +'package'=71 +'import'=72 +'class'=73 +'interface'=74 +'fun'=75 +'object'=76 +'val'=77 +'var'=78 +'typealias'=79 +'constructor'=80 +'by'=81 +'companion'=82 +'init'=83 +'this'=84 +'super'=85 +'typeof'=86 +'where'=87 +'if'=88 +'else'=89 +'when'=90 +'try'=91 +'catch'=92 +'finally'=93 +'for'=94 +'do'=95 +'while'=96 +'throw'=97 +'return'=98 +'continue'=99 +'break'=100 +'as'=101 +'is'=102 +'in'=103 +'out'=106 +'dynamic'=107 +'public'=108 +'private'=109 +'protected'=110 +'internal'=111 +'enum'=112 +'sealed'=113 +'annotation'=114 +'data'=115 +'inner'=116 +'value'=117 +'tailrec'=118 +'operator'=119 +'inline'=120 +'infix'=121 +'external'=122 +'suspend'=123 +'override'=124 +'abstract'=125 +'final'=126 +'open'=127 +'const'=128 +'lateinit'=129 +'vararg'=130 +'noinline'=131 +'crossinline'=132 +'reified'=133 +'expect'=134 +'actual'=135 +'null'=145 +'"""'=151 diff --git a/lib/archer/kotlin_parser/UnicodeClasses.g4 b/lib/archer/kotlin_parser/UnicodeClasses.g4 new file mode 100644 index 0000000..5372848 --- /dev/null +++ b/lib/archer/kotlin_parser/UnicodeClasses.g4 @@ -0,0 +1,1649 @@ +/** + * Kotlin lexical grammar in ANTLR4 notation (Unicode classes) + * + * Taken from http://www.antlr3.org/grammar/1345144569663/AntlrUnicode.txt + */ + +lexer grammar UnicodeClasses; + +UNICODE_CLASS_LL: + '\u0061'..'\u007A' | + '\u00B5' | + '\u00DF'..'\u00F6' | + '\u00F8'..'\u00FF' | + '\u0101' | + '\u0103' | + '\u0105' | + '\u0107' | + '\u0109' | + '\u010B' | + '\u010D' | + '\u010F' | + '\u0111' | + '\u0113' | + '\u0115' | + '\u0117' | + '\u0119' | + '\u011B' | + '\u011D' | + '\u011F' | + '\u0121' | + '\u0123' | + '\u0125' | + '\u0127' | + '\u0129' | + '\u012B' | + '\u012D' | + '\u012F' | + '\u0131' | + '\u0133' | + '\u0135' | + '\u0137' | + '\u0138' | + '\u013A' | + '\u013C' | + '\u013E' | + '\u0140' | + '\u0142' | + '\u0144' | + '\u0146' | + '\u0148' | + '\u0149' | + '\u014B' | + '\u014D' | + '\u014F' | + '\u0151' | + '\u0153' | + '\u0155' | + '\u0157' | + '\u0159' | + '\u015B' | + '\u015D' | + '\u015F' | + '\u0161' | + '\u0163' | + '\u0165' | + '\u0167' | + '\u0169' | + '\u016B' | + '\u016D' | + '\u016F' | + '\u0171' | + '\u0173' | + '\u0175' | + '\u0177' | + '\u017A' | + '\u017C' | + '\u017E'..'\u0180' | + '\u0183' | + '\u0185' | + '\u0188' | + '\u018C' | + '\u018D' | + '\u0192' | + '\u0195' | + '\u0199'..'\u019B' | + '\u019E' | + '\u01A1' | + '\u01A3' | + '\u01A5' | + '\u01A8' | + '\u01AA' | + '\u01AB' | + '\u01AD' | + '\u01B0' | + '\u01B4' | + '\u01B6' | + '\u01B9' | + '\u01BA' | + '\u01BD'..'\u01BF' | + '\u01C6' | + '\u01C9' | + '\u01CC' | + '\u01CE' | + '\u01D0' | + '\u01D2' | + '\u01D4' | + '\u01D6' | + '\u01D8' | + '\u01DA' | + '\u01DC' | + '\u01DD' | + '\u01DF' | + '\u01E1' | + '\u01E3' | + '\u01E5' | + '\u01E7' | + '\u01E9' | + '\u01EB' | + '\u01ED' | + '\u01EF' | + '\u01F0' | + '\u01F3' | + '\u01F5' | + '\u01F9' | + '\u01FB' | + '\u01FD' | + '\u01FF' | + '\u0201' | + '\u0203' | + '\u0205' | + '\u0207' | + '\u0209' | + '\u020B' | + '\u020D' | + '\u020F' | + '\u0211' | + '\u0213' | + '\u0215' | + '\u0217' | + '\u0219' | + '\u021B' | + '\u021D' | + '\u021F' | + '\u0221' | + '\u0223' | + '\u0225' | + '\u0227' | + '\u0229' | + '\u022B' | + '\u022D' | + '\u022F' | + '\u0231' | + '\u0233'..'\u0239' | + '\u023C' | + '\u023F' | + '\u0240' | + '\u0242' | + '\u0247' | + '\u0249' | + '\u024B' | + '\u024D' | + '\u024F'..'\u0293' | + '\u0295'..'\u02AF' | + '\u0371' | + '\u0373' | + '\u0377' | + '\u037B'..'\u037D' | + '\u0390' | + '\u03AC'..'\u03CE' | + '\u03D0' | + '\u03D1' | + '\u03D5'..'\u03D7' | + '\u03D9' | + '\u03DB' | + '\u03DD' | + '\u03DF' | + '\u03E1' | + '\u03E3' | + '\u03E5' | + '\u03E7' | + '\u03E9' | + '\u03EB' | + '\u03ED' | + '\u03EF'..'\u03F3' | + '\u03F5' | + '\u03F8' | + '\u03FB' | + '\u03FC' | + '\u0430'..'\u045F' | + '\u0461' | + '\u0463' | + '\u0465' | + '\u0467' | + '\u0469' | + '\u046B' | + '\u046D' | + '\u046F' | + '\u0471' | + '\u0473' | + '\u0475' | + '\u0477' | + '\u0479' | + '\u047B' | + '\u047D' | + '\u047F' | + '\u0481' | + '\u048B' | + '\u048D' | + '\u048F' | + '\u0491' | + '\u0493' | + '\u0495' | + '\u0497' | + '\u0499' | + '\u049B' | + '\u049D' | + '\u049F' | + '\u04A1' | + '\u04A3' | + '\u04A5' | + '\u04A7' | + '\u04A9' | + '\u04AB' | + '\u04AD' | + '\u04AF' | + '\u04B1' | + '\u04B3' | + '\u04B5' | + '\u04B7' | + '\u04B9' | + '\u04BB' | + '\u04BD' | + '\u04BF' | + '\u04C2' | + '\u04C4' | + '\u04C6' | + '\u04C8' | + '\u04CA' | + '\u04CC' | + '\u04CE' | + '\u04CF' | + '\u04D1' | + '\u04D3' | + '\u04D5' | + '\u04D7' | + '\u04D9' | + '\u04DB' | + '\u04DD' | + '\u04DF' | + '\u04E1' | + '\u04E3' | + '\u04E5' | + '\u04E7' | + '\u04E9' | + '\u04EB' | + '\u04ED' | + '\u04EF' | + '\u04F1' | + '\u04F3' | + '\u04F5' | + '\u04F7' | + '\u04F9' | + '\u04FB' | + '\u04FD' | + '\u04FF' | + '\u0501' | + '\u0503' | + '\u0505' | + '\u0507' | + '\u0509' | + '\u050B' | + '\u050D' | + '\u050F' | + '\u0511' | + '\u0513' | + '\u0515' | + '\u0517' | + '\u0519' | + '\u051B' | + '\u051D' | + '\u051F' | + '\u0521' | + '\u0523' | + '\u0525' | + '\u0527' | + '\u0561'..'\u0587' | + '\u1D00'..'\u1D2B' | + '\u1D6B'..'\u1D77' | + '\u1D79'..'\u1D9A' | + '\u1E01' | + '\u1E03' | + '\u1E05' | + '\u1E07' | + '\u1E09' | + '\u1E0B' | + '\u1E0D' | + '\u1E0F' | + '\u1E11' | + '\u1E13' | + '\u1E15' | + '\u1E17' | + '\u1E19' | + '\u1E1B' | + '\u1E1D' | + '\u1E1F' | + '\u1E21' | + '\u1E23' | + '\u1E25' | + '\u1E27' | + '\u1E29' | + '\u1E2B' | + '\u1E2D' | + '\u1E2F' | + '\u1E31' | + '\u1E33' | + '\u1E35' | + '\u1E37' | + '\u1E39' | + '\u1E3B' | + '\u1E3D' | + '\u1E3F' | + '\u1E41' | + '\u1E43' | + '\u1E45' | + '\u1E47' | + '\u1E49' | + '\u1E4B' | + '\u1E4D' | + '\u1E4F' | + '\u1E51' | + '\u1E53' | + '\u1E55' | + '\u1E57' | + '\u1E59' | + '\u1E5B' | + '\u1E5D' | + '\u1E5F' | + '\u1E61' | + '\u1E63' | + '\u1E65' | + '\u1E67' | + '\u1E69' | + '\u1E6B' | + '\u1E6D' | + '\u1E6F' | + '\u1E71' | + '\u1E73' | + '\u1E75' | + '\u1E77' | + '\u1E79' | + '\u1E7B' | + '\u1E7D' | + '\u1E7F' | + '\u1E81' | + '\u1E83' | + '\u1E85' | + '\u1E87' | + '\u1E89' | + '\u1E8B' | + '\u1E8D' | + '\u1E8F' | + '\u1E91' | + '\u1E93' | + '\u1E95'..'\u1E9D' | + '\u1E9F' | + '\u1EA1' | + '\u1EA3' | + '\u1EA5' | + '\u1EA7' | + '\u1EA9' | + '\u1EAB' | + '\u1EAD' | + '\u1EAF' | + '\u1EB1' | + '\u1EB3' | + '\u1EB5' | + '\u1EB7' | + '\u1EB9' | + '\u1EBB' | + '\u1EBD' | + '\u1EBF' | + '\u1EC1' | + '\u1EC3' | + '\u1EC5' | + '\u1EC7' | + '\u1EC9' | + '\u1ECB' | + '\u1ECD' | + '\u1ECF' | + '\u1ED1' | + '\u1ED3' | + '\u1ED5' | + '\u1ED7' | + '\u1ED9' | + '\u1EDB' | + '\u1EDD' | + '\u1EDF' | + '\u1EE1' | + '\u1EE3' | + '\u1EE5' | + '\u1EE7' | + '\u1EE9' | + '\u1EEB' | + '\u1EED' | + '\u1EEF' | + '\u1EF1' | + '\u1EF3' | + '\u1EF5' | + '\u1EF7' | + '\u1EF9' | + '\u1EFB' | + '\u1EFD' | + '\u1EFF'..'\u1F07' | + '\u1F10'..'\u1F15' | + '\u1F20'..'\u1F27' | + '\u1F30'..'\u1F37' | + '\u1F40'..'\u1F45' | + '\u1F50'..'\u1F57' | + '\u1F60'..'\u1F67' | + '\u1F70'..'\u1F7D' | + '\u1F80'..'\u1F87' | + '\u1F90'..'\u1F97' | + '\u1FA0'..'\u1FA7' | + '\u1FB0'..'\u1FB4' | + '\u1FB6' | + '\u1FB7' | + '\u1FBE' | + '\u1FC2'..'\u1FC4' | + '\u1FC6' | + '\u1FC7' | + '\u1FD0'..'\u1FD3' | + '\u1FD6' | + '\u1FD7' | + '\u1FE0'..'\u1FE7' | + '\u1FF2'..'\u1FF4' | + '\u1FF6' | + '\u1FF7' | + '\u210A' | + '\u210E' | + '\u210F' | + '\u2113' | + '\u212F' | + '\u2134' | + '\u2139' | + '\u213C' | + '\u213D' | + '\u2146'..'\u2149' | + '\u214E' | + '\u2184' | + '\u2C30'..'\u2C5E' | + '\u2C61' | + '\u2C65' | + '\u2C66' | + '\u2C68' | + '\u2C6A' | + '\u2C6C' | + '\u2C71' | + '\u2C73' | + '\u2C74' | + '\u2C76'..'\u2C7B' | + '\u2C81' | + '\u2C83' | + '\u2C85' | + '\u2C87' | + '\u2C89' | + '\u2C8B' | + '\u2C8D' | + '\u2C8F' | + '\u2C91' | + '\u2C93' | + '\u2C95' | + '\u2C97' | + '\u2C99' | + '\u2C9B' | + '\u2C9D' | + '\u2C9F' | + '\u2CA1' | + '\u2CA3' | + '\u2CA5' | + '\u2CA7' | + '\u2CA9' | + '\u2CAB' | + '\u2CAD' | + '\u2CAF' | + '\u2CB1' | + '\u2CB3' | + '\u2CB5' | + '\u2CB7' | + '\u2CB9' | + '\u2CBB' | + '\u2CBD' | + '\u2CBF' | + '\u2CC1' | + '\u2CC3' | + '\u2CC5' | + '\u2CC7' | + '\u2CC9' | + '\u2CCB' | + '\u2CCD' | + '\u2CCF' | + '\u2CD1' | + '\u2CD3' | + '\u2CD5' | + '\u2CD7' | + '\u2CD9' | + '\u2CDB' | + '\u2CDD' | + '\u2CDF' | + '\u2CE1' | + '\u2CE3' | + '\u2CE4' | + '\u2CEC' | + '\u2CEE' | + '\u2CF3' | + '\u2D00'..'\u2D25' | + '\u2D27' | + '\u2D2D' | + '\uA641' | + '\uA643' | + '\uA645' | + '\uA647' | + '\uA649' | + '\uA64B' | + '\uA64D' | + '\uA64F' | + '\uA651' | + '\uA653' | + '\uA655' | + '\uA657' | + '\uA659' | + '\uA65B' | + '\uA65D' | + '\uA65F' | + '\uA661' | + '\uA663' | + '\uA665' | + '\uA667' | + '\uA669' | + '\uA66B' | + '\uA66D' | + '\uA681' | + '\uA683' | + '\uA685' | + '\uA687' | + '\uA689' | + '\uA68B' | + '\uA68D' | + '\uA68F' | + '\uA691' | + '\uA693' | + '\uA695' | + '\uA697' | + '\uA723' | + '\uA725' | + '\uA727' | + '\uA729' | + '\uA72B' | + '\uA72D' | + '\uA72F'..'\uA731' | + '\uA733' | + '\uA735' | + '\uA737' | + '\uA739' | + '\uA73B' | + '\uA73D' | + '\uA73F' | + '\uA741' | + '\uA743' | + '\uA745' | + '\uA747' | + '\uA749' | + '\uA74B' | + '\uA74D' | + '\uA74F' | + '\uA751' | + '\uA753' | + '\uA755' | + '\uA757' | + '\uA759' | + '\uA75B' | + '\uA75D' | + '\uA75F' | + '\uA761' | + '\uA763' | + '\uA765' | + '\uA767' | + '\uA769' | + '\uA76B' | + '\uA76D' | + '\uA76F' | + '\uA771'..'\uA778' | + '\uA77A' | + '\uA77C' | + '\uA77F' | + '\uA781' | + '\uA783' | + '\uA785' | + '\uA787' | + '\uA78C' | + '\uA78E' | + '\uA791' | + '\uA793' | + '\uA7A1' | + '\uA7A3' | + '\uA7A5' | + '\uA7A7' | + '\uA7A9' | + '\uA7FA' | + '\uFB00'..'\uFB06' | + '\uFB13'..'\uFB17' | + '\uFF41'..'\uFF5A'; + +UNICODE_CLASS_LM: + '\u02B0'..'\u02C1' | + '\u02C6'..'\u02D1' | + '\u02E0'..'\u02E4' | + '\u02EC' | + '\u02EE' | + '\u0374' | + '\u037A' | + '\u0559' | + '\u0640' | + '\u06E5' | + '\u06E6' | + '\u07F4' | + '\u07F5' | + '\u07FA' | + '\u081A' | + '\u0824' | + '\u0828' | + '\u0971' | + '\u0E46' | + '\u0EC6' | + '\u10FC' | + '\u17D7' | + '\u1843' | + '\u1AA7' | + '\u1C78'..'\u1C7D' | + '\u1D2C'..'\u1D6A' | + '\u1D78' | + '\u1D9B'..'\u1DBF' | + '\u2071' | + '\u207F' | + '\u2090'..'\u209C' | + '\u2C7C' | + '\u2C7D' | + '\u2D6F' | + '\u2E2F' | + '\u3005' | + '\u3031'..'\u3035' | + '\u303B' | + '\u309D' | + '\u309E' | + '\u30FC'..'\u30FE' | + '\uA015' | + '\uA4F8'..'\uA4FD' | + '\uA60C' | + '\uA67F' | + '\uA717'..'\uA71F' | + '\uA770' | + '\uA788' | + '\uA7F8' | + '\uA7F9' | + '\uA9CF' | + '\uAA70' | + '\uAADD' | + '\uAAF3' | + '\uAAF4' | + '\uFF70' | + '\uFF9E' | + '\uFF9F'; + +UNICODE_CLASS_LO: + '\u00AA' | + '\u00BA' | + '\u01BB' | + '\u01C0'..'\u01C3' | + '\u0294' | + '\u05D0'..'\u05EA' | + '\u05F0'..'\u05F2' | + '\u0620'..'\u063F' | + '\u0641'..'\u064A' | + '\u066E' | + '\u066F' | + '\u0671'..'\u06D3' | + '\u06D5' | + '\u06EE' | + '\u06EF' | + '\u06FA'..'\u06FC' | + '\u06FF' | + '\u0710' | + '\u0712'..'\u072F' | + '\u074D'..'\u07A5' | + '\u07B1' | + '\u07CA'..'\u07EA' | + '\u0800'..'\u0815' | + '\u0840'..'\u0858' | + '\u08A0' | + '\u08A2'..'\u08AC' | + '\u0904'..'\u0939' | + '\u093D' | + '\u0950' | + '\u0958'..'\u0961' | + '\u0972'..'\u0977' | + '\u0979'..'\u097F' | + '\u0985'..'\u098C' | + '\u098F' | + '\u0990' | + '\u0993'..'\u09A8' | + '\u09AA'..'\u09B0' | + '\u09B2' | + '\u09B6'..'\u09B9' | + '\u09BD' | + '\u09CE' | + '\u09DC' | + '\u09DD' | + '\u09DF'..'\u09E1' | + '\u09F0' | + '\u09F1' | + '\u0A05'..'\u0A0A' | + '\u0A0F' | + '\u0A10' | + '\u0A13'..'\u0A28' | + '\u0A2A'..'\u0A30' | + '\u0A32' | + '\u0A33' | + '\u0A35' | + '\u0A36' | + '\u0A38' | + '\u0A39' | + '\u0A59'..'\u0A5C' | + '\u0A5E' | + '\u0A72'..'\u0A74' | + '\u0A85'..'\u0A8D' | + '\u0A8F'..'\u0A91' | + '\u0A93'..'\u0AA8' | + '\u0AAA'..'\u0AB0' | + '\u0AB2' | + '\u0AB3' | + '\u0AB5'..'\u0AB9' | + '\u0ABD' | + '\u0AD0' | + '\u0AE0' | + '\u0AE1' | + '\u0B05'..'\u0B0C' | + '\u0B0F' | + '\u0B10' | + '\u0B13'..'\u0B28' | + '\u0B2A'..'\u0B30' | + '\u0B32' | + '\u0B33' | + '\u0B35'..'\u0B39' | + '\u0B3D' | + '\u0B5C' | + '\u0B5D' | + '\u0B5F'..'\u0B61' | + '\u0B71' | + '\u0B83' | + '\u0B85'..'\u0B8A' | + '\u0B8E'..'\u0B90' | + '\u0B92'..'\u0B95' | + '\u0B99' | + '\u0B9A' | + '\u0B9C' | + '\u0B9E' | + '\u0B9F' | + '\u0BA3' | + '\u0BA4' | + '\u0BA8'..'\u0BAA' | + '\u0BAE'..'\u0BB9' | + '\u0BD0' | + '\u0C05'..'\u0C0C' | + '\u0C0E'..'\u0C10' | + '\u0C12'..'\u0C28' | + '\u0C2A'..'\u0C33' | + '\u0C35'..'\u0C39' | + '\u0C3D' | + '\u0C58' | + '\u0C59' | + '\u0C60' | + '\u0C61' | + '\u0C85'..'\u0C8C' | + '\u0C8E'..'\u0C90' | + '\u0C92'..'\u0CA8' | + '\u0CAA'..'\u0CB3' | + '\u0CB5'..'\u0CB9' | + '\u0CBD' | + '\u0CDE' | + '\u0CE0' | + '\u0CE1' | + '\u0CF1' | + '\u0CF2' | + '\u0D05'..'\u0D0C' | + '\u0D0E'..'\u0D10' | + '\u0D12'..'\u0D3A' | + '\u0D3D' | + '\u0D4E' | + '\u0D60' | + '\u0D61' | + '\u0D7A'..'\u0D7F' | + '\u0D85'..'\u0D96' | + '\u0D9A'..'\u0DB1' | + '\u0DB3'..'\u0DBB' | + '\u0DBD' | + '\u0DC0'..'\u0DC6' | + '\u0E01'..'\u0E30' | + '\u0E32' | + '\u0E33' | + '\u0E40'..'\u0E45' | + '\u0E81' | + '\u0E82' | + '\u0E84' | + '\u0E87' | + '\u0E88' | + '\u0E8A' | + '\u0E8D' | + '\u0E94'..'\u0E97' | + '\u0E99'..'\u0E9F' | + '\u0EA1'..'\u0EA3' | + '\u0EA5' | + '\u0EA7' | + '\u0EAA' | + '\u0EAB' | + '\u0EAD'..'\u0EB0' | + '\u0EB2' | + '\u0EB3' | + '\u0EBD' | + '\u0EC0'..'\u0EC4' | + '\u0EDC'..'\u0EDF' | + '\u0F00' | + '\u0F40'..'\u0F47' | + '\u0F49'..'\u0F6C' | + '\u0F88'..'\u0F8C' | + '\u1000'..'\u102A' | + '\u103F' | + '\u1050'..'\u1055' | + '\u105A'..'\u105D' | + '\u1061' | + '\u1065' | + '\u1066' | + '\u106E'..'\u1070' | + '\u1075'..'\u1081' | + '\u108E' | + '\u10D0'..'\u10FA' | + '\u10FD'..'\u1248' | + '\u124A'..'\u124D' | + '\u1250'..'\u1256' | + '\u1258' | + '\u125A'..'\u125D' | + '\u1260'..'\u1288' | + '\u128A'..'\u128D' | + '\u1290'..'\u12B0' | + '\u12B2'..'\u12B5' | + '\u12B8'..'\u12BE' | + '\u12C0' | + '\u12C2'..'\u12C5' | + '\u12C8'..'\u12D6' | + '\u12D8'..'\u1310' | + '\u1312'..'\u1315' | + '\u1318'..'\u135A' | + '\u1380'..'\u138F' | + '\u13A0'..'\u13F4' | + '\u1401'..'\u166C' | + '\u166F'..'\u167F' | + '\u1681'..'\u169A' | + '\u16A0'..'\u16EA' | + '\u1700'..'\u170C' | + '\u170E'..'\u1711' | + '\u1720'..'\u1731' | + '\u1740'..'\u1751' | + '\u1760'..'\u176C' | + '\u176E'..'\u1770' | + '\u1780'..'\u17B3' | + '\u17DC' | + '\u1820'..'\u1842' | + '\u1844'..'\u1877' | + '\u1880'..'\u18A8' | + '\u18AA' | + '\u18B0'..'\u18F5' | + '\u1900'..'\u191C' | + '\u1950'..'\u196D' | + '\u1970'..'\u1974' | + '\u1980'..'\u19AB' | + '\u19C1'..'\u19C7' | + '\u1A00'..'\u1A16' | + '\u1A20'..'\u1A54' | + '\u1B05'..'\u1B33' | + '\u1B45'..'\u1B4B' | + '\u1B83'..'\u1BA0' | + '\u1BAE' | + '\u1BAF' | + '\u1BBA'..'\u1BE5' | + '\u1C00'..'\u1C23' | + '\u1C4D'..'\u1C4F' | + '\u1C5A'..'\u1C77' | + '\u1CE9'..'\u1CEC' | + '\u1CEE'..'\u1CF1' | + '\u1CF5' | + '\u1CF6' | + '\u2135'..'\u2138' | + '\u2D30'..'\u2D67' | + '\u2D80'..'\u2D96' | + '\u2DA0'..'\u2DA6' | + '\u2DA8'..'\u2DAE' | + '\u2DB0'..'\u2DB6' | + '\u2DB8'..'\u2DBE' | + '\u2DC0'..'\u2DC6' | + '\u2DC8'..'\u2DCE' | + '\u2DD0'..'\u2DD6' | + '\u2DD8'..'\u2DDE' | + '\u3006' | + '\u303C' | + '\u3041'..'\u3096' | + '\u309F' | + '\u30A1'..'\u30FA' | + '\u30FF' | + '\u3105'..'\u312D' | + '\u3131'..'\u318E' | + '\u31A0'..'\u31BA' | + '\u31F0'..'\u31FF' | + '\u3400' | + '\u4DB5' | + '\u4E00' | + '\u9FCC' | + '\uA000'..'\uA014' | + '\uA016'..'\uA48C' | + '\uA4D0'..'\uA4F7' | + '\uA500'..'\uA60B' | + '\uA610'..'\uA61F' | + '\uA62A' | + '\uA62B' | + '\uA66E' | + '\uA6A0'..'\uA6E5' | + '\uA7FB'..'\uA801' | + '\uA803'..'\uA805' | + '\uA807'..'\uA80A' | + '\uA80C'..'\uA822' | + '\uA840'..'\uA873' | + '\uA882'..'\uA8B3' | + '\uA8F2'..'\uA8F7' | + '\uA8FB' | + '\uA90A'..'\uA925' | + '\uA930'..'\uA946' | + '\uA960'..'\uA97C' | + '\uA984'..'\uA9B2' | + '\uAA00'..'\uAA28' | + '\uAA40'..'\uAA42' | + '\uAA44'..'\uAA4B' | + '\uAA60'..'\uAA6F' | + '\uAA71'..'\uAA76' | + '\uAA7A' | + '\uAA80'..'\uAAAF' | + '\uAAB1' | + '\uAAB5' | + '\uAAB6' | + '\uAAB9'..'\uAABD' | + '\uAAC0' | + '\uAAC2' | + '\uAADB' | + '\uAADC' | + '\uAAE0'..'\uAAEA' | + '\uAAF2' | + '\uAB01'..'\uAB06' | + '\uAB09'..'\uAB0E' | + '\uAB11'..'\uAB16' | + '\uAB20'..'\uAB26' | + '\uAB28'..'\uAB2E' | + '\uABC0'..'\uABE2' | + '\uAC00' | + '\uD7A3' | + '\uD7B0'..'\uD7C6' | + '\uD7CB'..'\uD7FB' | + '\uF900'..'\uFA6D' | + '\uFA70'..'\uFAD9' | + '\uFB1D' | + '\uFB1F'..'\uFB28' | + '\uFB2A'..'\uFB36' | + '\uFB38'..'\uFB3C' | + '\uFB3E' | + '\uFB40' | + '\uFB41' | + '\uFB43' | + '\uFB44' | + '\uFB46'..'\uFBB1' | + '\uFBD3'..'\uFD3D' | + '\uFD50'..'\uFD8F' | + '\uFD92'..'\uFDC7' | + '\uFDF0'..'\uFDFB' | + '\uFE70'..'\uFE74' | + '\uFE76'..'\uFEFC' | + '\uFF66'..'\uFF6F' | + '\uFF71'..'\uFF9D' | + '\uFFA0'..'\uFFBE' | + '\uFFC2'..'\uFFC7' | + '\uFFCA'..'\uFFCF' | + '\uFFD2'..'\uFFD7' | + '\uFFDA'..'\uFFDC'; + +UNICODE_CLASS_LT: + '\u01C5' | + '\u01C8' | + '\u01CB' | + '\u01F2' | + '\u1F88'..'\u1F8F' | + '\u1F98'..'\u1F9F' | + '\u1FA8'..'\u1FAF' | + '\u1FBC' | + '\u1FCC' | + '\u1FFC'; + +UNICODE_CLASS_LU: + '\u0041'..'\u005A' | + '\u00C0'..'\u00D6' | + '\u00D8'..'\u00DE' | + '\u0100' | + '\u0102' | + '\u0104' | + '\u0106' | + '\u0108' | + '\u010A' | + '\u010C' | + '\u010E' | + '\u0110' | + '\u0112' | + '\u0114' | + '\u0116' | + '\u0118' | + '\u011A' | + '\u011C' | + '\u011E' | + '\u0120' | + '\u0122' | + '\u0124' | + '\u0126' | + '\u0128' | + '\u012A' | + '\u012C' | + '\u012E' | + '\u0130' | + '\u0132' | + '\u0134' | + '\u0136' | + '\u0139' | + '\u013B' | + '\u013D' | + '\u013F' | + '\u0141' | + '\u0143' | + '\u0145' | + '\u0147' | + '\u014A' | + '\u014C' | + '\u014E' | + '\u0150' | + '\u0152' | + '\u0154' | + '\u0156' | + '\u0158' | + '\u015A' | + '\u015C' | + '\u015E' | + '\u0160' | + '\u0162' | + '\u0164' | + '\u0166' | + '\u0168' | + '\u016A' | + '\u016C' | + '\u016E' | + '\u0170' | + '\u0172' | + '\u0174' | + '\u0176' | + '\u0178' | + '\u0179' | + '\u017B' | + '\u017D' | + '\u0181' | + '\u0182' | + '\u0184' | + '\u0186' | + '\u0187' | + '\u0189'..'\u018B' | + '\u018E'..'\u0191' | + '\u0193' | + '\u0194' | + '\u0196'..'\u0198' | + '\u019C' | + '\u019D' | + '\u019F' | + '\u01A0' | + '\u01A2' | + '\u01A4' | + '\u01A6' | + '\u01A7' | + '\u01A9' | + '\u01AC' | + '\u01AE' | + '\u01AF' | + '\u01B1'..'\u01B3' | + '\u01B5' | + '\u01B7' | + '\u01B8' | + '\u01BC' | + '\u01C4' | + '\u01C7' | + '\u01CA' | + '\u01CD' | + '\u01CF' | + '\u01D1' | + '\u01D3' | + '\u01D5' | + '\u01D7' | + '\u01D9' | + '\u01DB' | + '\u01DE' | + '\u01E0' | + '\u01E2' | + '\u01E4' | + '\u01E6' | + '\u01E8' | + '\u01EA' | + '\u01EC' | + '\u01EE' | + '\u01F1' | + '\u01F4' | + '\u01F6'..'\u01F8' | + '\u01FA' | + '\u01FC' | + '\u01FE' | + '\u0200' | + '\u0202' | + '\u0204' | + '\u0206' | + '\u0208' | + '\u020A' | + '\u020C' | + '\u020E' | + '\u0210' | + '\u0212' | + '\u0214' | + '\u0216' | + '\u0218' | + '\u021A' | + '\u021C' | + '\u021E' | + '\u0220' | + '\u0222' | + '\u0224' | + '\u0226' | + '\u0228' | + '\u022A' | + '\u022C' | + '\u022E' | + '\u0230' | + '\u0232' | + '\u023A' | + '\u023B' | + '\u023D' | + '\u023E' | + '\u0241' | + '\u0243'..'\u0246' | + '\u0248' | + '\u024A' | + '\u024C' | + '\u024E' | + '\u0370' | + '\u0372' | + '\u0376' | + '\u0386' | + '\u0388'..'\u038A' | + '\u038C' | + '\u038E' | + '\u038F' | + '\u0391'..'\u03A1' | + '\u03A3'..'\u03AB' | + '\u03CF' | + '\u03D2'..'\u03D4' | + '\u03D8' | + '\u03DA' | + '\u03DC' | + '\u03DE' | + '\u03E0' | + '\u03E2' | + '\u03E4' | + '\u03E6' | + '\u03E8' | + '\u03EA' | + '\u03EC' | + '\u03EE' | + '\u03F4' | + '\u03F7' | + '\u03F9' | + '\u03FA' | + '\u03FD'..'\u042F' | + '\u0460' | + '\u0462' | + '\u0464' | + '\u0466' | + '\u0468' | + '\u046A' | + '\u046C' | + '\u046E' | + '\u0470' | + '\u0472' | + '\u0474' | + '\u0476' | + '\u0478' | + '\u047A' | + '\u047C' | + '\u047E' | + '\u0480' | + '\u048A' | + '\u048C' | + '\u048E' | + '\u0490' | + '\u0492' | + '\u0494' | + '\u0496' | + '\u0498' | + '\u049A' | + '\u049C' | + '\u049E' | + '\u04A0' | + '\u04A2' | + '\u04A4' | + '\u04A6' | + '\u04A8' | + '\u04AA' | + '\u04AC' | + '\u04AE' | + '\u04B0' | + '\u04B2' | + '\u04B4' | + '\u04B6' | + '\u04B8' | + '\u04BA' | + '\u04BC' | + '\u04BE' | + '\u04C0' | + '\u04C1' | + '\u04C3' | + '\u04C5' | + '\u04C7' | + '\u04C9' | + '\u04CB' | + '\u04CD' | + '\u04D0' | + '\u04D2' | + '\u04D4' | + '\u04D6' | + '\u04D8' | + '\u04DA' | + '\u04DC' | + '\u04DE' | + '\u04E0' | + '\u04E2' | + '\u04E4' | + '\u04E6' | + '\u04E8' | + '\u04EA' | + '\u04EC' | + '\u04EE' | + '\u04F0' | + '\u04F2' | + '\u04F4' | + '\u04F6' | + '\u04F8' | + '\u04FA' | + '\u04FC' | + '\u04FE' | + '\u0500' | + '\u0502' | + '\u0504' | + '\u0506' | + '\u0508' | + '\u050A' | + '\u050C' | + '\u050E' | + '\u0510' | + '\u0512' | + '\u0514' | + '\u0516' | + '\u0518' | + '\u051A' | + '\u051C' | + '\u051E' | + '\u0520' | + '\u0522' | + '\u0524' | + '\u0526' | + '\u0531'..'\u0556' | + '\u10A0'..'\u10C5' | + '\u10C7' | + '\u10CD' | + '\u1E00' | + '\u1E02' | + '\u1E04' | + '\u1E06' | + '\u1E08' | + '\u1E0A' | + '\u1E0C' | + '\u1E0E' | + '\u1E10' | + '\u1E12' | + '\u1E14' | + '\u1E16' | + '\u1E18' | + '\u1E1A' | + '\u1E1C' | + '\u1E1E' | + '\u1E20' | + '\u1E22' | + '\u1E24' | + '\u1E26' | + '\u1E28' | + '\u1E2A' | + '\u1E2C' | + '\u1E2E' | + '\u1E30' | + '\u1E32' | + '\u1E34' | + '\u1E36' | + '\u1E38' | + '\u1E3A' | + '\u1E3C' | + '\u1E3E' | + '\u1E40' | + '\u1E42' | + '\u1E44' | + '\u1E46' | + '\u1E48' | + '\u1E4A' | + '\u1E4C' | + '\u1E4E' | + '\u1E50' | + '\u1E52' | + '\u1E54' | + '\u1E56' | + '\u1E58' | + '\u1E5A' | + '\u1E5C' | + '\u1E5E' | + '\u1E60' | + '\u1E62' | + '\u1E64' | + '\u1E66' | + '\u1E68' | + '\u1E6A' | + '\u1E6C' | + '\u1E6E' | + '\u1E70' | + '\u1E72' | + '\u1E74' | + '\u1E76' | + '\u1E78' | + '\u1E7A' | + '\u1E7C' | + '\u1E7E' | + '\u1E80' | + '\u1E82' | + '\u1E84' | + '\u1E86' | + '\u1E88' | + '\u1E8A' | + '\u1E8C' | + '\u1E8E' | + '\u1E90' | + '\u1E92' | + '\u1E94' | + '\u1E9E' | + '\u1EA0' | + '\u1EA2' | + '\u1EA4' | + '\u1EA6' | + '\u1EA8' | + '\u1EAA' | + '\u1EAC' | + '\u1EAE' | + '\u1EB0' | + '\u1EB2' | + '\u1EB4' | + '\u1EB6' | + '\u1EB8' | + '\u1EBA' | + '\u1EBC' | + '\u1EBE' | + '\u1EC0' | + '\u1EC2' | + '\u1EC4' | + '\u1EC6' | + '\u1EC8' | + '\u1ECA' | + '\u1ECC' | + '\u1ECE' | + '\u1ED0' | + '\u1ED2' | + '\u1ED4' | + '\u1ED6' | + '\u1ED8' | + '\u1EDA' | + '\u1EDC' | + '\u1EDE' | + '\u1EE0' | + '\u1EE2' | + '\u1EE4' | + '\u1EE6' | + '\u1EE8' | + '\u1EEA' | + '\u1EEC' | + '\u1EEE' | + '\u1EF0' | + '\u1EF2' | + '\u1EF4' | + '\u1EF6' | + '\u1EF8' | + '\u1EFA' | + '\u1EFC' | + '\u1EFE' | + '\u1F08'..'\u1F0F' | + '\u1F18'..'\u1F1D' | + '\u1F28'..'\u1F2F' | + '\u1F38'..'\u1F3F' | + '\u1F48'..'\u1F4D' | + '\u1F59' | + '\u1F5B' | + '\u1F5D' | + '\u1F5F' | + '\u1F68'..'\u1F6F' | + '\u1FB8'..'\u1FBB' | + '\u1FC8'..'\u1FCB' | + '\u1FD8'..'\u1FDB' | + '\u1FE8'..'\u1FEC' | + '\u1FF8'..'\u1FFB' | + '\u2102' | + '\u2107' | + '\u210B'..'\u210D' | + '\u2110'..'\u2112' | + '\u2115' | + '\u2119'..'\u211D' | + '\u2124' | + '\u2126' | + '\u2128' | + '\u212A'..'\u212D' | + '\u2130'..'\u2133' | + '\u213E' | + '\u213F' | + '\u2145' | + '\u2183' | + '\u2C00'..'\u2C2E' | + '\u2C60' | + '\u2C62'..'\u2C64' | + '\u2C67' | + '\u2C69' | + '\u2C6B' | + '\u2C6D'..'\u2C70' | + '\u2C72' | + '\u2C75' | + '\u2C7E'..'\u2C80' | + '\u2C82' | + '\u2C84' | + '\u2C86' | + '\u2C88' | + '\u2C8A' | + '\u2C8C' | + '\u2C8E' | + '\u2C90' | + '\u2C92' | + '\u2C94' | + '\u2C96' | + '\u2C98' | + '\u2C9A' | + '\u2C9C' | + '\u2C9E' | + '\u2CA0' | + '\u2CA2' | + '\u2CA4' | + '\u2CA6' | + '\u2CA8' | + '\u2CAA' | + '\u2CAC' | + '\u2CAE' | + '\u2CB0' | + '\u2CB2' | + '\u2CB4' | + '\u2CB6' | + '\u2CB8' | + '\u2CBA' | + '\u2CBC' | + '\u2CBE' | + '\u2CC0' | + '\u2CC2' | + '\u2CC4' | + '\u2CC6' | + '\u2CC8' | + '\u2CCA' | + '\u2CCC' | + '\u2CCE' | + '\u2CD0' | + '\u2CD2' | + '\u2CD4' | + '\u2CD6' | + '\u2CD8' | + '\u2CDA' | + '\u2CDC' | + '\u2CDE' | + '\u2CE0' | + '\u2CE2' | + '\u2CEB' | + '\u2CED' | + '\u2CF2' | + '\uA640' | + '\uA642' | + '\uA644' | + '\uA646' | + '\uA648' | + '\uA64A' | + '\uA64C' | + '\uA64E' | + '\uA650' | + '\uA652' | + '\uA654' | + '\uA656' | + '\uA658' | + '\uA65A' | + '\uA65C' | + '\uA65E' | + '\uA660' | + '\uA662' | + '\uA664' | + '\uA666' | + '\uA668' | + '\uA66A' | + '\uA66C' | + '\uA680' | + '\uA682' | + '\uA684' | + '\uA686' | + '\uA688' | + '\uA68A' | + '\uA68C' | + '\uA68E' | + '\uA690' | + '\uA692' | + '\uA694' | + '\uA696' | + '\uA722' | + '\uA724' | + '\uA726' | + '\uA728' | + '\uA72A' | + '\uA72C' | + '\uA72E' | + '\uA732' | + '\uA734' | + '\uA736' | + '\uA738' | + '\uA73A' | + '\uA73C' | + '\uA73E' | + '\uA740' | + '\uA742' | + '\uA744' | + '\uA746' | + '\uA748' | + '\uA74A' | + '\uA74C' | + '\uA74E' | + '\uA750' | + '\uA752' | + '\uA754' | + '\uA756' | + '\uA758' | + '\uA75A' | + '\uA75C' | + '\uA75E' | + '\uA760' | + '\uA762' | + '\uA764' | + '\uA766' | + '\uA768' | + '\uA76A' | + '\uA76C' | + '\uA76E' | + '\uA779' | + '\uA77B' | + '\uA77D' | + '\uA77E' | + '\uA780' | + '\uA782' | + '\uA784' | + '\uA786' | + '\uA78B' | + '\uA78D' | + '\uA790' | + '\uA792' | + '\uA7A0' | + '\uA7A2' | + '\uA7A4' | + '\uA7A6' | + '\uA7A8' | + '\uA7AA' | + '\uFF21'..'\uFF3A'; + +UNICODE_CLASS_ND: + '\u0030'..'\u0039' | + '\u0660'..'\u0669' | + '\u06F0'..'\u06F9' | + '\u07C0'..'\u07C9' | + '\u0966'..'\u096F' | + '\u09E6'..'\u09EF' | + '\u0A66'..'\u0A6F' | + '\u0AE6'..'\u0AEF' | + '\u0B66'..'\u0B6F' | + '\u0BE6'..'\u0BEF' | + '\u0C66'..'\u0C6F' | + '\u0CE6'..'\u0CEF' | + '\u0D66'..'\u0D6F' | + '\u0E50'..'\u0E59' | + '\u0ED0'..'\u0ED9' | + '\u0F20'..'\u0F29' | + '\u1040'..'\u1049' | + '\u1090'..'\u1099' | + '\u17E0'..'\u17E9' | + '\u1810'..'\u1819' | + '\u1946'..'\u194F' | + '\u19D0'..'\u19D9' | + '\u1A80'..'\u1A89' | + '\u1A90'..'\u1A99' | + '\u1B50'..'\u1B59' | + '\u1BB0'..'\u1BB9' | + '\u1C40'..'\u1C49' | + '\u1C50'..'\u1C59' | + '\uA620'..'\uA629' | + '\uA8D0'..'\uA8D9' | + '\uA900'..'\uA909' | + '\uA9D0'..'\uA9D9' | + '\uAA50'..'\uAA59' | + '\uABF0'..'\uABF9' | + '\uFF10'..'\uFF19'; + +UNICODE_CLASS_NL: + '\u16EE'..'\u16F0' | + '\u2160'..'\u2182' | + '\u2185'..'\u2188' | + '\u3007' | + '\u3021'..'\u3029' | + '\u3038'..'\u303A' | + '\uA6E6'..'\uA6EF'; \ No newline at end of file diff --git a/lib/archer/kotlin_parser/kotlin_lexer.go b/lib/archer/kotlin_parser/kotlin_lexer.go new file mode 100644 index 0000000..b068ac5 --- /dev/null +++ b/lib/archer/kotlin_parser/kotlin_lexer.go @@ -0,0 +1,1706 @@ +// Code generated from java-escape by ANTLR 4.11.1. DO NOT EDIT. + +package kotlin_parser + +import ( + "fmt" + "sync" + "unicode" + + "github.com/antlr/antlr4/runtime/Go/antlr/v4" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type KotlinLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var kotlinlexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + channelNames []string + modeNames []string + literalNames []string + symbolicNames []string + ruleNames []string + predictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func kotlinlexerLexerInit() { + staticData := &kotlinlexerLexerStaticData + staticData.channelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.modeNames = []string{ + "DEFAULT_MODE", "LineString", "MultiLineString", "Inside", + } + staticData.literalNames = []string{ + "", "", "", "", "", "", "'...'", "'.'", "','", "'('", "')'", "'['", + "']'", "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", "'--'", + "'&&'", "'||'", "", "'!'", "':'", "';'", "'='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "';;'", "'#'", "'@'", + "", "", "", "", "'?'", "'<'", "'>'", "'<='", "'>='", "'!='", "'!=='", + "'as?'", "'=='", "'==='", "'''", "'&'", "", "", "", "", "", "'file'", + "'field'", "'property'", "'get'", "'set'", "'receiver'", "'param'", + "'setparam'", "'delegate'", "'package'", "'import'", "'class'", "'interface'", + "'fun'", "'object'", "'val'", "'var'", "'typealias'", "'constructor'", + "'by'", "'companion'", "'init'", "'this'", "'super'", "'typeof'", "'where'", + "'if'", "'else'", "'when'", "'try'", "'catch'", "'finally'", "'for'", + "'do'", "'while'", "'throw'", "'return'", "'continue'", "'break'", "'as'", + "'is'", "'in'", "", "", "'out'", "'dynamic'", "'public'", "'private'", + "'protected'", "'internal'", "'enum'", "'sealed'", "'annotation'", "'data'", + "'inner'", "'value'", "'tailrec'", "'operator'", "'inline'", "'infix'", + "'external'", "'suspend'", "'override'", "'abstract'", "'final'", "'open'", + "'const'", "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", + "'reified'", "'expect'", "'actual'", "", "", "", "", "", "", "", "", + "", "'null'", "", "", "", "", "", "'\"\"\"'", + } + staticData.symbolicNames = []string{ + "", "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", + "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", + "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", + "EXCL_WS", "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", + "SUB_ASSIGNMENT", "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", + "ARROW", "DOUBLE_ARROW", "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", + "HASH", "AT_NO_WS", "AT_POST_WS", "AT_PRE_WS", "AT_BOTH_WS", "QUEST_WS", + "QUEST_NO_WS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", + "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "AMP", "RETURN_AT", "CONTINUE_AT", + "BREAK_AT", "THIS_AT", "SUPER_AT", "FILE", "FIELD", "PROPERTY", "GET", + "SET", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", "PACKAGE", "IMPORT", + "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", + "BY", "COMPANION", "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", + "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", + "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", + "OUT", "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", + "SEALED", "ANNOTATION", "DATA", "INNER", "VALUE", "TAILREC", "OPERATOR", + "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", + "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", + "EXPECT", "ACTUAL", "RealLiteral", "FloatLiteral", "DoubleLiteral", + "IntegerLiteral", "HexLiteral", "BinLiteral", "UnsignedLiteral", "LongLiteral", + "BooleanLiteral", "NullLiteral", "CharacterLiteral", "Identifier", "IdentifierOrSoftKey", + "FieldIdentifier", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "QUOTE_CLOSE", "LineStrRef", + "LineStrText", "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", "MultiLineStrExprStart", + "Inside_Comment", "Inside_WS", "Inside_NL", "ErrorCharacter", + } + staticData.ruleNames = []string{ + "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "Hidden", + "RESERVED", "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", + "LCURL", "RCURL", "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", + "CONJ", "DISJ", "EXCL_WS", "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", + "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", + "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", + "HASH", "AT_NO_WS", "AT_POST_WS", "AT_PRE_WS", "AT_BOTH_WS", "QUEST_WS", + "QUEST_NO_WS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", + "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "AMP", "RETURN_AT", "CONTINUE_AT", + "BREAK_AT", "THIS_AT", "SUPER_AT", "FILE", "FIELD", "PROPERTY", "GET", + "SET", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", "PACKAGE", "IMPORT", + "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", + "BY", "COMPANION", "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", + "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", + "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", + "OUT", "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", + "SEALED", "ANNOTATION", "DATA", "INNER", "VALUE", "TAILREC", "OPERATOR", + "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", + "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", + "EXPECT", "ACTUAL", "DecDigit", "DecDigitNoZero", "DecDigitOrSeparator", + "DecDigits", "DoubleExponent", "RealLiteral", "FloatLiteral", "DoubleLiteral", + "IntegerLiteral", "HexDigit", "HexDigitOrSeparator", "HexLiteral", "BinDigit", + "BinDigitOrSeparator", "BinLiteral", "UnsignedLiteral", "LongLiteral", + "BooleanLiteral", "NullLiteral", "CharacterLiteral", "UnicodeDigit", + "Identifier", "IdentifierOrSoftKey", "FieldIdentifier", "UniCharacterLiteral", + "EscapedIdentifier", "EscapeSeq", "Letter", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", + "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "QUOTE_CLOSE", + "LineStrRef", "LineStrText", "LineStrEscapedChar", "LineStrExprStart", + "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", + "MultiLineStrExprStart", "Inside_RPAREN", "Inside_RSQUARE", "Inside_LPAREN", + "Inside_LSQUARE", "Inside_LCURL", "Inside_RCURL", "Inside_DOT", "Inside_COMMA", + "Inside_MULT", "Inside_MOD", "Inside_DIV", "Inside_ADD", "Inside_SUB", + "Inside_INCR", "Inside_DECR", "Inside_CONJ", "Inside_DISJ", "Inside_EXCL_WS", + "Inside_EXCL_NO_WS", "Inside_COLON", "Inside_SEMICOLON", "Inside_ASSIGNMENT", + "Inside_ADD_ASSIGNMENT", "Inside_SUB_ASSIGNMENT", "Inside_MULT_ASSIGNMENT", + "Inside_DIV_ASSIGNMENT", "Inside_MOD_ASSIGNMENT", "Inside_ARROW", "Inside_DOUBLE_ARROW", + "Inside_RANGE", "Inside_RESERVED", "Inside_COLONCOLON", "Inside_DOUBLE_SEMICOLON", + "Inside_HASH", "Inside_AT_NO_WS", "Inside_AT_POST_WS", "Inside_AT_PRE_WS", + "Inside_AT_BOTH_WS", "Inside_QUEST_WS", "Inside_QUEST_NO_WS", "Inside_LANGLE", + "Inside_RANGLE", "Inside_LE", "Inside_GE", "Inside_EXCL_EQ", "Inside_EXCL_EQEQ", + "Inside_IS", "Inside_NOT_IS", "Inside_NOT_IN", "Inside_AS", "Inside_AS_SAFE", + "Inside_EQEQ", "Inside_EQEQEQ", "Inside_SINGLE_QUOTE", "Inside_AMP", + "Inside_QUOTE_OPEN", "Inside_TRIPLE_QUOTE_OPEN", "Inside_VAL", "Inside_VAR", + "Inside_FUN", "Inside_OBJECT", "Inside_SUPER", "Inside_IN", "Inside_OUT", + "Inside_FIELD", "Inside_FILE", "Inside_PROPERTY", "Inside_GET", "Inside_SET", + "Inside_RECEIVER", "Inside_PARAM", "Inside_SETPARAM", "Inside_DELEGATE", + "Inside_THROW", "Inside_RETURN", "Inside_CONTINUE", "Inside_BREAK", + "Inside_RETURN_AT", "Inside_CONTINUE_AT", "Inside_BREAK_AT", "Inside_IF", + "Inside_ELSE", "Inside_WHEN", "Inside_TRY", "Inside_CATCH", "Inside_FINALLY", + "Inside_FOR", "Inside_DO", "Inside_WHILE", "Inside_PUBLIC", "Inside_PRIVATE", + "Inside_PROTECTED", "Inside_INTERNAL", "Inside_ENUM", "Inside_SEALED", + "Inside_ANNOTATION", "Inside_DATA", "Inside_INNER", "Inside_VALUE", + "Inside_TAILREC", "Inside_OPERATOR", "Inside_INLINE", "Inside_INFIX", + "Inside_EXTERNAL", "Inside_SUSPEND", "Inside_OVERRIDE", "Inside_ABSTRACT", + "Inside_FINAL", "Inside_OPEN", "Inside_CONST", "Inside_LATEINIT", "Inside_VARARG", + "Inside_NOINLINE", "Inside_CROSSINLINE", "Inside_REIFIED", "Inside_EXPECT", + "Inside_ACTUAL", "Inside_BooleanLiteral", "Inside_IntegerLiteral", "Inside_HexLiteral", + "Inside_BinLiteral", "Inside_CharacterLiteral", "Inside_RealLiteral", + "Inside_NullLiteral", "Inside_LongLiteral", "Inside_UnsignedLiteral", + "Inside_Identifier", "Inside_Comment", "Inside_WS", "Inside_NL", "ErrorCharacter", + } + staticData.predictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 172, 2239, 6, -1, 6, -1, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, + 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, + 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, + 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, + 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, + 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, + 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, + 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, + 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, + 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, + 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, + 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, + 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, + 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, + 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, + 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, + 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, + 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, + 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, + 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, + 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, + 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, + 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, + 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, + 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, + 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, + 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, + 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, + 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, + 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, + 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, + 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, + 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, + 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, + 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, + 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, + 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, + 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, + 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, + 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, + 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, + 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, + 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, + 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, + 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, + 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, + 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, + 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, + 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, + 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, + 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, + 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, + 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, + 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, + 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, + 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, + 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, + 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, + 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, + 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, + 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, + 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, + 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, + 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, + 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, + 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, + 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, + 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 637, 8, 0, 10, 0, 12, 0, 640, 9, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 647, 8, 1, 10, 1, 12, 1, 650, 9, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 661, 8, 2, 10, 2, + 12, 2, 664, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, + 3, 4, 675, 8, 4, 3, 4, 677, 8, 4, 1, 5, 1, 5, 1, 5, 3, 5, 682, 8, 5, 1, + 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, + 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, + 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, + 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, + 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, + 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 30, + 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, + 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, + 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, + 41, 1, 41, 3, 41, 782, 8, 41, 1, 42, 1, 42, 3, 42, 786, 8, 42, 1, 42, 1, + 42, 1, 43, 1, 43, 3, 43, 792, 8, 43, 1, 43, 1, 43, 1, 43, 3, 43, 797, 8, + 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, + 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, + 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, + 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, + 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, + 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, + 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, + 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, + 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, + 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, + 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, + 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, + 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, + 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, + 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, + 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, + 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, + 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, + 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, + 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, + 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, + 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, + 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, + 1, 101, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1146, 8, 104, 1, 105, 1, 105, 1, + 105, 1, 105, 1, 105, 1, 105, 3, 105, 1154, 8, 105, 1, 106, 1, 106, 1, 106, + 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, + 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, + 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, + 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, + 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, + 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, + 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, + 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, + 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, + 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, + 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, + 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, + 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, + 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, + 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, + 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, + 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 3, 138, 1389, 8, 138, 1, 139, 1, + 139, 5, 139, 1393, 8, 139, 10, 139, 12, 139, 1396, 9, 139, 1, 139, 1, 139, + 1, 139, 3, 139, 1401, 8, 139, 1, 140, 1, 140, 3, 140, 1405, 8, 140, 1, + 140, 1, 140, 1, 141, 1, 141, 3, 141, 1411, 8, 141, 1, 142, 1, 142, 1, 142, + 1, 142, 1, 142, 1, 142, 3, 142, 1419, 8, 142, 1, 143, 3, 143, 1422, 8, + 143, 1, 143, 1, 143, 1, 143, 3, 143, 1427, 8, 143, 1, 143, 1, 143, 1, 143, + 3, 143, 1432, 8, 143, 1, 144, 1, 144, 5, 144, 1436, 8, 144, 10, 144, 12, + 144, 1439, 9, 144, 1, 144, 1, 144, 1, 144, 3, 144, 1444, 8, 144, 1, 145, + 1, 145, 1, 146, 1, 146, 3, 146, 1450, 8, 146, 1, 147, 1, 147, 1, 147, 1, + 147, 5, 147, 1456, 8, 147, 10, 147, 12, 147, 1459, 9, 147, 1, 147, 1, 147, + 1, 147, 1, 147, 1, 147, 3, 147, 1466, 8, 147, 1, 148, 1, 148, 1, 149, 1, + 149, 3, 149, 1472, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 1478, + 8, 150, 10, 150, 12, 150, 1481, 9, 150, 1, 150, 1, 150, 1, 150, 1, 150, + 1, 150, 3, 150, 1488, 8, 150, 1, 151, 1, 151, 1, 151, 3, 151, 1493, 8, + 151, 1, 151, 1, 151, 3, 151, 1497, 8, 151, 1, 152, 1, 152, 1, 152, 3, 152, + 1502, 8, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, + 153, 1, 153, 1, 153, 1, 153, 3, 153, 1515, 8, 153, 1, 154, 1, 154, 1, 154, + 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 3, 155, 1525, 8, 155, 1, 155, 1, + 155, 1, 156, 1, 156, 1, 157, 1, 157, 3, 157, 1533, 8, 157, 1, 157, 1, 157, + 1, 157, 5, 157, 1538, 8, 157, 10, 157, 12, 157, 1541, 9, 157, 1, 157, 1, + 157, 4, 157, 1545, 8, 157, 11, 157, 12, 157, 1546, 1, 157, 3, 157, 1550, + 8, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 1600, 8, 158, 1, 159, 1, 159, 1, + 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, + 161, 1, 161, 1, 162, 1, 162, 3, 162, 1617, 8, 162, 1, 163, 1, 163, 1, 163, + 1, 163, 1, 163, 3, 163, 1624, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, + 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 1, + 167, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 171, 1, 171, 1, + 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 175, 4, + 175, 1657, 8, 175, 11, 175, 12, 175, 1658, 1, 175, 3, 175, 1662, 8, 175, + 1, 176, 1, 176, 3, 176, 1666, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, + 177, 1, 178, 3, 178, 1674, 8, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, + 1, 178, 1, 179, 4, 179, 1683, 8, 179, 11, 179, 12, 179, 1684, 1, 180, 1, + 180, 1, 181, 4, 181, 1690, 8, 181, 11, 181, 12, 181, 1691, 1, 181, 3, 181, + 1695, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, + 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, + 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, + 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, + 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, + 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, + 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, + 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, + 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 200, 1, 200, 1, 200, 3, 200, 1779, 8, 200, 1, 200, 1, 200, 1, 201, 1, 201, + 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, + 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, + 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, + 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, + 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, + 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, + 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, + 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, + 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, + 3, 221, 1866, 8, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, + 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, + 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, + 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, + 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, + 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, + 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, + 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, + 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, + 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, + 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, + 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, + 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, + 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, + 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, + 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, + 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, + 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, + 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, + 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, + 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, + 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, + 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, + 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, + 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, + 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, + 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, + 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, + 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, + 310, 3, 310, 2226, 8, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, + 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 648, 0, 314, 4, 1, 6, + 2, 8, 3, 10, 4, 12, 5, 14, 0, 16, 6, 18, 7, 20, 8, 22, 9, 24, 10, 26, 11, + 28, 12, 30, 13, 32, 14, 34, 15, 36, 16, 38, 17, 40, 18, 42, 19, 44, 20, + 46, 21, 48, 22, 50, 23, 52, 24, 54, 25, 56, 26, 58, 27, 60, 28, 62, 29, + 64, 30, 66, 31, 68, 32, 70, 33, 72, 34, 74, 35, 76, 36, 78, 37, 80, 38, + 82, 39, 84, 40, 86, 41, 88, 42, 90, 43, 92, 44, 94, 45, 96, 46, 98, 47, + 100, 48, 102, 49, 104, 50, 106, 51, 108, 52, 110, 53, 112, 54, 114, 55, + 116, 56, 118, 57, 120, 58, 122, 59, 124, 60, 126, 61, 128, 62, 130, 63, + 132, 64, 134, 65, 136, 66, 138, 67, 140, 68, 142, 69, 144, 70, 146, 71, + 148, 72, 150, 73, 152, 74, 154, 75, 156, 76, 158, 77, 160, 78, 162, 79, + 164, 80, 166, 81, 168, 82, 170, 83, 172, 84, 174, 85, 176, 86, 178, 87, + 180, 88, 182, 89, 184, 90, 186, 91, 188, 92, 190, 93, 192, 94, 194, 95, + 196, 96, 198, 97, 200, 98, 202, 99, 204, 100, 206, 101, 208, 102, 210, + 103, 212, 104, 214, 105, 216, 106, 218, 107, 220, 108, 222, 109, 224, 110, + 226, 111, 228, 112, 230, 113, 232, 114, 234, 115, 236, 116, 238, 117, 240, + 118, 242, 119, 244, 120, 246, 121, 248, 122, 250, 123, 252, 124, 254, 125, + 256, 126, 258, 127, 260, 128, 262, 129, 264, 130, 266, 131, 268, 132, 270, + 133, 272, 134, 274, 135, 276, 0, 278, 0, 280, 0, 282, 0, 284, 0, 286, 136, + 288, 137, 290, 138, 292, 139, 294, 0, 296, 0, 298, 140, 300, 0, 302, 0, + 304, 141, 306, 142, 308, 143, 310, 144, 312, 145, 314, 146, 316, 0, 318, + 147, 320, 148, 322, 149, 324, 0, 326, 0, 328, 0, 330, 0, 332, 150, 334, + 151, 336, 152, 338, 153, 340, 154, 342, 155, 344, 156, 346, 157, 348, 158, + 350, 159, 352, 160, 354, 161, 356, 162, 358, 163, 360, 164, 362, 165, 364, + 166, 366, 167, 368, 168, 370, 0, 372, 0, 374, 0, 376, 0, 378, 0, 380, 0, + 382, 0, 384, 0, 386, 0, 388, 0, 390, 0, 392, 0, 394, 0, 396, 0, 398, 0, + 400, 0, 402, 0, 404, 0, 406, 0, 408, 0, 410, 0, 412, 0, 414, 0, 416, 0, + 418, 0, 420, 0, 422, 0, 424, 0, 426, 0, 428, 0, 430, 0, 432, 0, 434, 0, + 436, 0, 438, 0, 440, 0, 442, 0, 444, 0, 446, 0, 448, 0, 450, 0, 452, 0, + 454, 0, 456, 0, 458, 0, 460, 0, 462, 0, 464, 0, 466, 0, 468, 0, 470, 0, + 472, 0, 474, 0, 476, 0, 478, 0, 480, 0, 482, 0, 484, 0, 486, 0, 488, 0, + 490, 0, 492, 0, 494, 0, 496, 0, 498, 0, 500, 0, 502, 0, 504, 0, 506, 0, + 508, 0, 510, 0, 512, 0, 514, 0, 516, 0, 518, 0, 520, 0, 522, 0, 524, 0, + 526, 0, 528, 0, 530, 0, 532, 0, 534, 0, 536, 0, 538, 0, 540, 0, 542, 0, + 544, 0, 546, 0, 548, 0, 550, 0, 552, 0, 554, 0, 556, 0, 558, 0, 560, 0, + 562, 0, 564, 0, 566, 0, 568, 0, 570, 0, 572, 0, 574, 0, 576, 0, 578, 0, + 580, 0, 582, 0, 584, 0, 586, 0, 588, 0, 590, 0, 592, 0, 594, 0, 596, 0, + 598, 0, 600, 0, 602, 0, 604, 0, 606, 0, 608, 0, 610, 0, 612, 0, 614, 0, + 616, 0, 618, 0, 620, 0, 622, 0, 624, 169, 626, 170, 628, 171, 630, 172, + 4, 0, 1, 2, 3, 23, 2, 0, 10, 10, 13, 13, 3, 0, 9, 9, 12, 12, 32, 32, 2, + 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 2, 0, 70, 70, 102, 102, 3, 0, + 48, 57, 65, 70, 97, 102, 2, 0, 88, 88, 120, 120, 1, 0, 48, 49, 2, 0, 66, + 66, 98, 98, 2, 0, 85, 85, 117, 117, 2, 0, 76, 76, 108, 108, 4, 0, 10, 10, + 13, 13, 39, 39, 92, 92, 3, 0, 10, 10, 13, 13, 96, 96, 8, 0, 34, 34, 36, + 36, 39, 39, 92, 92, 98, 98, 110, 110, 114, 114, 116, 116, 582, 0, 97, 122, + 181, 181, 223, 246, 248, 255, 257, 257, 259, 259, 261, 261, 263, 263, 265, + 265, 267, 267, 269, 269, 271, 271, 273, 273, 275, 275, 277, 277, 279, 279, + 281, 281, 283, 283, 285, 285, 287, 287, 289, 289, 291, 291, 293, 293, 295, + 295, 297, 297, 299, 299, 301, 301, 303, 303, 305, 305, 307, 307, 309, 309, + 311, 312, 314, 314, 316, 316, 318, 318, 320, 320, 322, 322, 324, 324, 326, + 326, 328, 329, 331, 331, 333, 333, 335, 335, 337, 337, 339, 339, 341, 341, + 343, 343, 345, 345, 347, 347, 349, 349, 351, 351, 353, 353, 355, 355, 357, + 357, 359, 359, 361, 361, 363, 363, 365, 365, 367, 367, 369, 369, 371, 371, + 373, 373, 375, 375, 378, 378, 380, 380, 382, 384, 387, 387, 389, 389, 392, + 392, 396, 397, 402, 402, 405, 405, 409, 411, 414, 414, 417, 417, 419, 419, + 421, 421, 424, 424, 426, 427, 429, 429, 432, 432, 436, 436, 438, 438, 441, + 442, 445, 447, 454, 454, 457, 457, 460, 460, 462, 462, 464, 464, 466, 466, + 468, 468, 470, 470, 472, 472, 474, 474, 476, 477, 479, 479, 481, 481, 483, + 483, 485, 485, 487, 487, 489, 489, 491, 491, 493, 493, 495, 496, 499, 499, + 501, 501, 505, 505, 507, 507, 509, 509, 511, 511, 513, 513, 515, 515, 517, + 517, 519, 519, 521, 521, 523, 523, 525, 525, 527, 527, 529, 529, 531, 531, + 533, 533, 535, 535, 537, 537, 539, 539, 541, 541, 543, 543, 545, 545, 547, + 547, 549, 549, 551, 551, 553, 553, 555, 555, 557, 557, 559, 559, 561, 561, + 563, 569, 572, 572, 575, 576, 578, 578, 583, 583, 585, 585, 587, 587, 589, + 589, 591, 659, 661, 687, 881, 881, 883, 883, 887, 887, 891, 893, 912, 912, + 940, 974, 976, 977, 981, 983, 985, 985, 987, 987, 989, 989, 991, 991, 993, + 993, 995, 995, 997, 997, 999, 999, 1001, 1001, 1003, 1003, 1005, 1005, + 1007, 1011, 1013, 1013, 1016, 1016, 1019, 1020, 1072, 1119, 1121, 1121, + 1123, 1123, 1125, 1125, 1127, 1127, 1129, 1129, 1131, 1131, 1133, 1133, + 1135, 1135, 1137, 1137, 1139, 1139, 1141, 1141, 1143, 1143, 1145, 1145, + 1147, 1147, 1149, 1149, 1151, 1151, 1153, 1153, 1163, 1163, 1165, 1165, + 1167, 1167, 1169, 1169, 1171, 1171, 1173, 1173, 1175, 1175, 1177, 1177, + 1179, 1179, 1181, 1181, 1183, 1183, 1185, 1185, 1187, 1187, 1189, 1189, + 1191, 1191, 1193, 1193, 1195, 1195, 1197, 1197, 1199, 1199, 1201, 1201, + 1203, 1203, 1205, 1205, 1207, 1207, 1209, 1209, 1211, 1211, 1213, 1213, + 1215, 1215, 1218, 1218, 1220, 1220, 1222, 1222, 1224, 1224, 1226, 1226, + 1228, 1228, 1230, 1231, 1233, 1233, 1235, 1235, 1237, 1237, 1239, 1239, + 1241, 1241, 1243, 1243, 1245, 1245, 1247, 1247, 1249, 1249, 1251, 1251, + 1253, 1253, 1255, 1255, 1257, 1257, 1259, 1259, 1261, 1261, 1263, 1263, + 1265, 1265, 1267, 1267, 1269, 1269, 1271, 1271, 1273, 1273, 1275, 1275, + 1277, 1277, 1279, 1279, 1281, 1281, 1283, 1283, 1285, 1285, 1287, 1287, + 1289, 1289, 1291, 1291, 1293, 1293, 1295, 1295, 1297, 1297, 1299, 1299, + 1301, 1301, 1303, 1303, 1305, 1305, 1307, 1307, 1309, 1309, 1311, 1311, + 1313, 1313, 1315, 1315, 1317, 1317, 1319, 1319, 1377, 1415, 7424, 7467, + 7531, 7543, 7545, 7578, 7681, 7681, 7683, 7683, 7685, 7685, 7687, 7687, + 7689, 7689, 7691, 7691, 7693, 7693, 7695, 7695, 7697, 7697, 7699, 7699, + 7701, 7701, 7703, 7703, 7705, 7705, 7707, 7707, 7709, 7709, 7711, 7711, + 7713, 7713, 7715, 7715, 7717, 7717, 7719, 7719, 7721, 7721, 7723, 7723, + 7725, 7725, 7727, 7727, 7729, 7729, 7731, 7731, 7733, 7733, 7735, 7735, + 7737, 7737, 7739, 7739, 7741, 7741, 7743, 7743, 7745, 7745, 7747, 7747, + 7749, 7749, 7751, 7751, 7753, 7753, 7755, 7755, 7757, 7757, 7759, 7759, + 7761, 7761, 7763, 7763, 7765, 7765, 7767, 7767, 7769, 7769, 7771, 7771, + 7773, 7773, 7775, 7775, 7777, 7777, 7779, 7779, 7781, 7781, 7783, 7783, + 7785, 7785, 7787, 7787, 7789, 7789, 7791, 7791, 7793, 7793, 7795, 7795, + 7797, 7797, 7799, 7799, 7801, 7801, 7803, 7803, 7805, 7805, 7807, 7807, + 7809, 7809, 7811, 7811, 7813, 7813, 7815, 7815, 7817, 7817, 7819, 7819, + 7821, 7821, 7823, 7823, 7825, 7825, 7827, 7827, 7829, 7837, 7839, 7839, + 7841, 7841, 7843, 7843, 7845, 7845, 7847, 7847, 7849, 7849, 7851, 7851, + 7853, 7853, 7855, 7855, 7857, 7857, 7859, 7859, 7861, 7861, 7863, 7863, + 7865, 7865, 7867, 7867, 7869, 7869, 7871, 7871, 7873, 7873, 7875, 7875, + 7877, 7877, 7879, 7879, 7881, 7881, 7883, 7883, 7885, 7885, 7887, 7887, + 7889, 7889, 7891, 7891, 7893, 7893, 7895, 7895, 7897, 7897, 7899, 7899, + 7901, 7901, 7903, 7903, 7905, 7905, 7907, 7907, 7909, 7909, 7911, 7911, + 7913, 7913, 7915, 7915, 7917, 7917, 7919, 7919, 7921, 7921, 7923, 7923, + 7925, 7925, 7927, 7927, 7929, 7929, 7931, 7931, 7933, 7933, 7935, 7943, + 7952, 7957, 7968, 7975, 7984, 7991, 8000, 8005, 8016, 8023, 8032, 8039, + 8048, 8061, 8064, 8071, 8080, 8087, 8096, 8103, 8112, 8116, 8118, 8119, + 8126, 8126, 8130, 8132, 8134, 8135, 8144, 8147, 8150, 8151, 8160, 8167, + 8178, 8180, 8182, 8183, 8458, 8458, 8462, 8463, 8467, 8467, 8495, 8495, + 8500, 8500, 8505, 8505, 8508, 8509, 8518, 8521, 8526, 8526, 8580, 8580, + 11312, 11358, 11361, 11361, 11365, 11366, 11368, 11368, 11370, 11370, 11372, + 11372, 11377, 11377, 11379, 11380, 11382, 11387, 11393, 11393, 11395, 11395, + 11397, 11397, 11399, 11399, 11401, 11401, 11403, 11403, 11405, 11405, 11407, + 11407, 11409, 11409, 11411, 11411, 11413, 11413, 11415, 11415, 11417, 11417, + 11419, 11419, 11421, 11421, 11423, 11423, 11425, 11425, 11427, 11427, 11429, + 11429, 11431, 11431, 11433, 11433, 11435, 11435, 11437, 11437, 11439, 11439, + 11441, 11441, 11443, 11443, 11445, 11445, 11447, 11447, 11449, 11449, 11451, + 11451, 11453, 11453, 11455, 11455, 11457, 11457, 11459, 11459, 11461, 11461, + 11463, 11463, 11465, 11465, 11467, 11467, 11469, 11469, 11471, 11471, 11473, + 11473, 11475, 11475, 11477, 11477, 11479, 11479, 11481, 11481, 11483, 11483, + 11485, 11485, 11487, 11487, 11489, 11489, 11491, 11492, 11500, 11500, 11502, + 11502, 11507, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 42561, 42561, + 42563, 42563, 42565, 42565, 42567, 42567, 42569, 42569, 42571, 42571, 42573, + 42573, 42575, 42575, 42577, 42577, 42579, 42579, 42581, 42581, 42583, 42583, + 42585, 42585, 42587, 42587, 42589, 42589, 42591, 42591, 42593, 42593, 42595, + 42595, 42597, 42597, 42599, 42599, 42601, 42601, 42603, 42603, 42605, 42605, + 42625, 42625, 42627, 42627, 42629, 42629, 42631, 42631, 42633, 42633, 42635, + 42635, 42637, 42637, 42639, 42639, 42641, 42641, 42643, 42643, 42645, 42645, + 42647, 42647, 42787, 42787, 42789, 42789, 42791, 42791, 42793, 42793, 42795, + 42795, 42797, 42797, 42799, 42801, 42803, 42803, 42805, 42805, 42807, 42807, + 42809, 42809, 42811, 42811, 42813, 42813, 42815, 42815, 42817, 42817, 42819, + 42819, 42821, 42821, 42823, 42823, 42825, 42825, 42827, 42827, 42829, 42829, + 42831, 42831, 42833, 42833, 42835, 42835, 42837, 42837, 42839, 42839, 42841, + 42841, 42843, 42843, 42845, 42845, 42847, 42847, 42849, 42849, 42851, 42851, + 42853, 42853, 42855, 42855, 42857, 42857, 42859, 42859, 42861, 42861, 42863, + 42863, 42865, 42872, 42874, 42874, 42876, 42876, 42879, 42879, 42881, 42881, + 42883, 42883, 42885, 42885, 42887, 42887, 42892, 42892, 42894, 42894, 42897, + 42897, 42899, 42899, 42913, 42913, 42915, 42915, 42917, 42917, 42919, 42919, + 42921, 42921, 43002, 43002, 64256, 64262, 64275, 64279, 65345, 65370, 51, + 0, 688, 705, 710, 721, 736, 740, 748, 748, 750, 750, 884, 884, 890, 890, + 1369, 1369, 1600, 1600, 1765, 1766, 2036, 2037, 2042, 2042, 2074, 2074, + 2084, 2084, 2088, 2088, 2417, 2417, 3654, 3654, 3782, 3782, 4348, 4348, + 6103, 6103, 6211, 6211, 6823, 6823, 7288, 7293, 7468, 7530, 7544, 7544, + 7579, 7615, 8305, 8305, 8319, 8319, 8336, 8348, 11388, 11389, 11631, 11631, + 11823, 11823, 12293, 12293, 12337, 12341, 12347, 12347, 12445, 12446, 12540, + 12542, 40981, 40981, 42232, 42237, 42508, 42508, 42623, 42623, 42775, 42783, + 42864, 42864, 42888, 42888, 43000, 43001, 43471, 43471, 43632, 43632, 43741, + 43741, 43763, 43764, 65392, 65392, 65438, 65439, 289, 0, 170, 170, 186, + 186, 443, 443, 448, 451, 660, 660, 1488, 1514, 1520, 1522, 1568, 1599, + 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1774, 1775, 1786, 1788, + 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, + 2048, 2069, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, + 2384, 2384, 2392, 2401, 2418, 2423, 2425, 2431, 2437, 2444, 2447, 2448, + 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, + 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, + 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, + 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, + 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, + 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, + 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, + 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, + 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, + 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, + 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, + 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, + 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, + 3585, 3632, 3634, 3635, 3648, 3653, 3713, 3714, 3716, 3716, 3719, 3720, + 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, + 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, + 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, + 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, + 4213, 4225, 4238, 4238, 4304, 4346, 4349, 4680, 4682, 4685, 4688, 4694, + 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, + 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, + 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, + 5792, 5866, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, + 5998, 6000, 6016, 6067, 6108, 6108, 6176, 6210, 6212, 6263, 6272, 6312, + 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, + 6593, 6599, 6656, 6678, 6688, 6740, 6917, 6963, 6981, 6987, 7043, 7072, + 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7401, 7404, + 7406, 7409, 7413, 7414, 8501, 8504, 11568, 11623, 11648, 11670, 11680, + 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, + 11728, 11734, 11736, 11742, 12294, 12294, 12348, 12348, 12353, 12438, 12447, + 12447, 12449, 12538, 12543, 12543, 12549, 12589, 12593, 12686, 12704, 12730, + 12784, 12799, 13312, 13312, 19893, 19893, 19968, 19968, 40908, 40908, 40960, + 40980, 40982, 42124, 42192, 42231, 42240, 42507, 42512, 42527, 42538, 42539, + 42606, 42606, 42656, 42725, 43003, 43009, 43011, 43013, 43015, 43018, 43020, + 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, + 43312, 43334, 43360, 43388, 43396, 43442, 43520, 43560, 43584, 43586, 43588, + 43595, 43616, 43631, 43633, 43638, 43642, 43642, 43648, 43695, 43697, 43697, + 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43740, 43744, + 43754, 43762, 43762, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, + 43816, 43822, 43968, 44002, 44032, 44032, 55203, 55203, 55216, 55238, 55243, + 55291, 63744, 64109, 64112, 64217, 64285, 64285, 64287, 64296, 64298, 64310, + 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, + 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, + 65382, 65391, 65393, 65437, 65440, 65470, 65474, 65479, 65482, 65487, 65490, + 65495, 65498, 65500, 10, 0, 453, 453, 456, 456, 459, 459, 498, 498, 8072, + 8079, 8088, 8095, 8104, 8111, 8124, 8124, 8140, 8140, 8188, 8188, 576, + 0, 65, 90, 192, 214, 216, 222, 256, 256, 258, 258, 260, 260, 262, 262, + 264, 264, 266, 266, 268, 268, 270, 270, 272, 272, 274, 274, 276, 276, 278, + 278, 280, 280, 282, 282, 284, 284, 286, 286, 288, 288, 290, 290, 292, 292, + 294, 294, 296, 296, 298, 298, 300, 300, 302, 302, 304, 304, 306, 306, 308, + 308, 310, 310, 313, 313, 315, 315, 317, 317, 319, 319, 321, 321, 323, 323, + 325, 325, 327, 327, 330, 330, 332, 332, 334, 334, 336, 336, 338, 338, 340, + 340, 342, 342, 344, 344, 346, 346, 348, 348, 350, 350, 352, 352, 354, 354, + 356, 356, 358, 358, 360, 360, 362, 362, 364, 364, 366, 366, 368, 368, 370, + 370, 372, 372, 374, 374, 376, 377, 379, 379, 381, 381, 385, 386, 388, 388, + 390, 391, 393, 395, 398, 401, 403, 404, 406, 408, 412, 413, 415, 416, 418, + 418, 420, 420, 422, 423, 425, 425, 428, 428, 430, 431, 433, 435, 437, 437, + 439, 440, 444, 444, 452, 452, 455, 455, 458, 458, 461, 461, 463, 463, 465, + 465, 467, 467, 469, 469, 471, 471, 473, 473, 475, 475, 478, 478, 480, 480, + 482, 482, 484, 484, 486, 486, 488, 488, 490, 490, 492, 492, 494, 494, 497, + 497, 500, 500, 502, 504, 506, 506, 508, 508, 510, 510, 512, 512, 514, 514, + 516, 516, 518, 518, 520, 520, 522, 522, 524, 524, 526, 526, 528, 528, 530, + 530, 532, 532, 534, 534, 536, 536, 538, 538, 540, 540, 542, 542, 544, 544, + 546, 546, 548, 548, 550, 550, 552, 552, 554, 554, 556, 556, 558, 558, 560, + 560, 562, 562, 570, 571, 573, 574, 577, 577, 579, 582, 584, 584, 586, 586, + 588, 588, 590, 590, 880, 880, 882, 882, 886, 886, 902, 902, 904, 906, 908, + 908, 910, 911, 913, 929, 931, 939, 975, 975, 978, 980, 984, 984, 986, 986, + 988, 988, 990, 990, 992, 992, 994, 994, 996, 996, 998, 998, 1000, 1000, + 1002, 1002, 1004, 1004, 1006, 1006, 1012, 1012, 1015, 1015, 1017, 1018, + 1021, 1071, 1120, 1120, 1122, 1122, 1124, 1124, 1126, 1126, 1128, 1128, + 1130, 1130, 1132, 1132, 1134, 1134, 1136, 1136, 1138, 1138, 1140, 1140, + 1142, 1142, 1144, 1144, 1146, 1146, 1148, 1148, 1150, 1150, 1152, 1152, + 1162, 1162, 1164, 1164, 1166, 1166, 1168, 1168, 1170, 1170, 1172, 1172, + 1174, 1174, 1176, 1176, 1178, 1178, 1180, 1180, 1182, 1182, 1184, 1184, + 1186, 1186, 1188, 1188, 1190, 1190, 1192, 1192, 1194, 1194, 1196, 1196, + 1198, 1198, 1200, 1200, 1202, 1202, 1204, 1204, 1206, 1206, 1208, 1208, + 1210, 1210, 1212, 1212, 1214, 1214, 1216, 1217, 1219, 1219, 1221, 1221, + 1223, 1223, 1225, 1225, 1227, 1227, 1229, 1229, 1232, 1232, 1234, 1234, + 1236, 1236, 1238, 1238, 1240, 1240, 1242, 1242, 1244, 1244, 1246, 1246, + 1248, 1248, 1250, 1250, 1252, 1252, 1254, 1254, 1256, 1256, 1258, 1258, + 1260, 1260, 1262, 1262, 1264, 1264, 1266, 1266, 1268, 1268, 1270, 1270, + 1272, 1272, 1274, 1274, 1276, 1276, 1278, 1278, 1280, 1280, 1282, 1282, + 1284, 1284, 1286, 1286, 1288, 1288, 1290, 1290, 1292, 1292, 1294, 1294, + 1296, 1296, 1298, 1298, 1300, 1300, 1302, 1302, 1304, 1304, 1306, 1306, + 1308, 1308, 1310, 1310, 1312, 1312, 1314, 1314, 1316, 1316, 1318, 1318, + 1329, 1366, 4256, 4293, 4295, 4295, 4301, 4301, 7680, 7680, 7682, 7682, + 7684, 7684, 7686, 7686, 7688, 7688, 7690, 7690, 7692, 7692, 7694, 7694, + 7696, 7696, 7698, 7698, 7700, 7700, 7702, 7702, 7704, 7704, 7706, 7706, + 7708, 7708, 7710, 7710, 7712, 7712, 7714, 7714, 7716, 7716, 7718, 7718, + 7720, 7720, 7722, 7722, 7724, 7724, 7726, 7726, 7728, 7728, 7730, 7730, + 7732, 7732, 7734, 7734, 7736, 7736, 7738, 7738, 7740, 7740, 7742, 7742, + 7744, 7744, 7746, 7746, 7748, 7748, 7750, 7750, 7752, 7752, 7754, 7754, + 7756, 7756, 7758, 7758, 7760, 7760, 7762, 7762, 7764, 7764, 7766, 7766, + 7768, 7768, 7770, 7770, 7772, 7772, 7774, 7774, 7776, 7776, 7778, 7778, + 7780, 7780, 7782, 7782, 7784, 7784, 7786, 7786, 7788, 7788, 7790, 7790, + 7792, 7792, 7794, 7794, 7796, 7796, 7798, 7798, 7800, 7800, 7802, 7802, + 7804, 7804, 7806, 7806, 7808, 7808, 7810, 7810, 7812, 7812, 7814, 7814, + 7816, 7816, 7818, 7818, 7820, 7820, 7822, 7822, 7824, 7824, 7826, 7826, + 7828, 7828, 7838, 7838, 7840, 7840, 7842, 7842, 7844, 7844, 7846, 7846, + 7848, 7848, 7850, 7850, 7852, 7852, 7854, 7854, 7856, 7856, 7858, 7858, + 7860, 7860, 7862, 7862, 7864, 7864, 7866, 7866, 7868, 7868, 7870, 7870, + 7872, 7872, 7874, 7874, 7876, 7876, 7878, 7878, 7880, 7880, 7882, 7882, + 7884, 7884, 7886, 7886, 7888, 7888, 7890, 7890, 7892, 7892, 7894, 7894, + 7896, 7896, 7898, 7898, 7900, 7900, 7902, 7902, 7904, 7904, 7906, 7906, + 7908, 7908, 7910, 7910, 7912, 7912, 7914, 7914, 7916, 7916, 7918, 7918, + 7920, 7920, 7922, 7922, 7924, 7924, 7926, 7926, 7928, 7928, 7930, 7930, + 7932, 7932, 7934, 7934, 7944, 7951, 7960, 7965, 7976, 7983, 7992, 7999, + 8008, 8013, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8031, 8040, 8047, + 8120, 8123, 8136, 8139, 8152, 8155, 8168, 8172, 8184, 8187, 8450, 8450, + 8455, 8455, 8459, 8461, 8464, 8466, 8469, 8469, 8473, 8477, 8484, 8484, + 8486, 8486, 8488, 8488, 8490, 8493, 8496, 8499, 8510, 8511, 8517, 8517, + 8579, 8579, 11264, 11310, 11360, 11360, 11362, 11364, 11367, 11367, 11369, + 11369, 11371, 11371, 11373, 11376, 11378, 11378, 11381, 11381, 11390, 11392, + 11394, 11394, 11396, 11396, 11398, 11398, 11400, 11400, 11402, 11402, 11404, + 11404, 11406, 11406, 11408, 11408, 11410, 11410, 11412, 11412, 11414, 11414, + 11416, 11416, 11418, 11418, 11420, 11420, 11422, 11422, 11424, 11424, 11426, + 11426, 11428, 11428, 11430, 11430, 11432, 11432, 11434, 11434, 11436, 11436, + 11438, 11438, 11440, 11440, 11442, 11442, 11444, 11444, 11446, 11446, 11448, + 11448, 11450, 11450, 11452, 11452, 11454, 11454, 11456, 11456, 11458, 11458, + 11460, 11460, 11462, 11462, 11464, 11464, 11466, 11466, 11468, 11468, 11470, + 11470, 11472, 11472, 11474, 11474, 11476, 11476, 11478, 11478, 11480, 11480, + 11482, 11482, 11484, 11484, 11486, 11486, 11488, 11488, 11490, 11490, 11499, + 11499, 11501, 11501, 11506, 11506, 42560, 42560, 42562, 42562, 42564, 42564, + 42566, 42566, 42568, 42568, 42570, 42570, 42572, 42572, 42574, 42574, 42576, + 42576, 42578, 42578, 42580, 42580, 42582, 42582, 42584, 42584, 42586, 42586, + 42588, 42588, 42590, 42590, 42592, 42592, 42594, 42594, 42596, 42596, 42598, + 42598, 42600, 42600, 42602, 42602, 42604, 42604, 42624, 42624, 42626, 42626, + 42628, 42628, 42630, 42630, 42632, 42632, 42634, 42634, 42636, 42636, 42638, + 42638, 42640, 42640, 42642, 42642, 42644, 42644, 42646, 42646, 42786, 42786, + 42788, 42788, 42790, 42790, 42792, 42792, 42794, 42794, 42796, 42796, 42798, + 42798, 42802, 42802, 42804, 42804, 42806, 42806, 42808, 42808, 42810, 42810, + 42812, 42812, 42814, 42814, 42816, 42816, 42818, 42818, 42820, 42820, 42822, + 42822, 42824, 42824, 42826, 42826, 42828, 42828, 42830, 42830, 42832, 42832, + 42834, 42834, 42836, 42836, 42838, 42838, 42840, 42840, 42842, 42842, 42844, + 42844, 42846, 42846, 42848, 42848, 42850, 42850, 42852, 42852, 42854, 42854, + 42856, 42856, 42858, 42858, 42860, 42860, 42862, 42862, 42873, 42873, 42875, + 42875, 42877, 42878, 42880, 42880, 42882, 42882, 42884, 42884, 42886, 42886, + 42891, 42891, 42893, 42893, 42896, 42896, 42898, 42898, 42912, 42912, 42914, + 42914, 42916, 42916, 42918, 42918, 42920, 42920, 42922, 42922, 65313, 65338, + 35, 0, 48, 57, 1632, 1641, 1776, 1785, 1984, 1993, 2406, 2415, 2534, 2543, + 2662, 2671, 2790, 2799, 2918, 2927, 3046, 3055, 3174, 3183, 3302, 3311, + 3430, 3439, 3664, 3673, 3792, 3801, 3872, 3881, 4160, 4169, 4240, 4249, + 6112, 6121, 6160, 6169, 6470, 6479, 6608, 6617, 6784, 6793, 6800, 6809, + 6992, 7001, 7088, 7097, 7232, 7241, 7248, 7257, 42528, 42537, 43216, 43225, + 43264, 43273, 43472, 43481, 43600, 43609, 44016, 44025, 65296, 65305, 7, + 0, 5870, 5872, 8544, 8578, 8581, 8584, 12295, 12295, 12321, 12329, 12344, + 12346, 42726, 42735, 3, 0, 34, 34, 36, 36, 92, 92, 2, 0, 34, 34, 36, 36, + 2326, 0, 4, 1, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 8, 1, 0, 0, 0, 0, 10, 1, 0, + 0, 0, 0, 12, 1, 0, 0, 0, 0, 16, 1, 0, 0, 0, 0, 18, 1, 0, 0, 0, 0, 20, 1, + 0, 0, 0, 0, 22, 1, 0, 0, 0, 0, 24, 1, 0, 0, 0, 0, 26, 1, 0, 0, 0, 0, 28, + 1, 0, 0, 0, 0, 30, 1, 0, 0, 0, 0, 32, 1, 0, 0, 0, 0, 34, 1, 0, 0, 0, 0, + 36, 1, 0, 0, 0, 0, 38, 1, 0, 0, 0, 0, 40, 1, 0, 0, 0, 0, 42, 1, 0, 0, 0, + 0, 44, 1, 0, 0, 0, 0, 46, 1, 0, 0, 0, 0, 48, 1, 0, 0, 0, 0, 50, 1, 0, 0, + 0, 0, 52, 1, 0, 0, 0, 0, 54, 1, 0, 0, 0, 0, 56, 1, 0, 0, 0, 0, 58, 1, 0, + 0, 0, 0, 60, 1, 0, 0, 0, 0, 62, 1, 0, 0, 0, 0, 64, 1, 0, 0, 0, 0, 66, 1, + 0, 0, 0, 0, 68, 1, 0, 0, 0, 0, 70, 1, 0, 0, 0, 0, 72, 1, 0, 0, 0, 0, 74, + 1, 0, 0, 0, 0, 76, 1, 0, 0, 0, 0, 78, 1, 0, 0, 0, 0, 80, 1, 0, 0, 0, 0, + 82, 1, 0, 0, 0, 0, 84, 1, 0, 0, 0, 0, 86, 1, 0, 0, 0, 0, 88, 1, 0, 0, 0, + 0, 90, 1, 0, 0, 0, 0, 92, 1, 0, 0, 0, 0, 94, 1, 0, 0, 0, 0, 96, 1, 0, 0, + 0, 0, 98, 1, 0, 0, 0, 0, 100, 1, 0, 0, 0, 0, 102, 1, 0, 0, 0, 0, 104, 1, + 0, 0, 0, 0, 106, 1, 0, 0, 0, 0, 108, 1, 0, 0, 0, 0, 110, 1, 0, 0, 0, 0, + 112, 1, 0, 0, 0, 0, 114, 1, 0, 0, 0, 0, 116, 1, 0, 0, 0, 0, 118, 1, 0, + 0, 0, 0, 120, 1, 0, 0, 0, 0, 122, 1, 0, 0, 0, 0, 124, 1, 0, 0, 0, 0, 126, + 1, 0, 0, 0, 0, 128, 1, 0, 0, 0, 0, 130, 1, 0, 0, 0, 0, 132, 1, 0, 0, 0, + 0, 134, 1, 0, 0, 0, 0, 136, 1, 0, 0, 0, 0, 138, 1, 0, 0, 0, 0, 140, 1, + 0, 0, 0, 0, 142, 1, 0, 0, 0, 0, 144, 1, 0, 0, 0, 0, 146, 1, 0, 0, 0, 0, + 148, 1, 0, 0, 0, 0, 150, 1, 0, 0, 0, 0, 152, 1, 0, 0, 0, 0, 154, 1, 0, + 0, 0, 0, 156, 1, 0, 0, 0, 0, 158, 1, 0, 0, 0, 0, 160, 1, 0, 0, 0, 0, 162, + 1, 0, 0, 0, 0, 164, 1, 0, 0, 0, 0, 166, 1, 0, 0, 0, 0, 168, 1, 0, 0, 0, + 0, 170, 1, 0, 0, 0, 0, 172, 1, 0, 0, 0, 0, 174, 1, 0, 0, 0, 0, 176, 1, + 0, 0, 0, 0, 178, 1, 0, 0, 0, 0, 180, 1, 0, 0, 0, 0, 182, 1, 0, 0, 0, 0, + 184, 1, 0, 0, 0, 0, 186, 1, 0, 0, 0, 0, 188, 1, 0, 0, 0, 0, 190, 1, 0, + 0, 0, 0, 192, 1, 0, 0, 0, 0, 194, 1, 0, 0, 0, 0, 196, 1, 0, 0, 0, 0, 198, + 1, 0, 0, 0, 0, 200, 1, 0, 0, 0, 0, 202, 1, 0, 0, 0, 0, 204, 1, 0, 0, 0, + 0, 206, 1, 0, 0, 0, 0, 208, 1, 0, 0, 0, 0, 210, 1, 0, 0, 0, 0, 212, 1, + 0, 0, 0, 0, 214, 1, 0, 0, 0, 0, 216, 1, 0, 0, 0, 0, 218, 1, 0, 0, 0, 0, + 220, 1, 0, 0, 0, 0, 222, 1, 0, 0, 0, 0, 224, 1, 0, 0, 0, 0, 226, 1, 0, + 0, 0, 0, 228, 1, 0, 0, 0, 0, 230, 1, 0, 0, 0, 0, 232, 1, 0, 0, 0, 0, 234, + 1, 0, 0, 0, 0, 236, 1, 0, 0, 0, 0, 238, 1, 0, 0, 0, 0, 240, 1, 0, 0, 0, + 0, 242, 1, 0, 0, 0, 0, 244, 1, 0, 0, 0, 0, 246, 1, 0, 0, 0, 0, 248, 1, + 0, 0, 0, 0, 250, 1, 0, 0, 0, 0, 252, 1, 0, 0, 0, 0, 254, 1, 0, 0, 0, 0, + 256, 1, 0, 0, 0, 0, 258, 1, 0, 0, 0, 0, 260, 1, 0, 0, 0, 0, 262, 1, 0, + 0, 0, 0, 264, 1, 0, 0, 0, 0, 266, 1, 0, 0, 0, 0, 268, 1, 0, 0, 0, 0, 270, + 1, 0, 0, 0, 0, 272, 1, 0, 0, 0, 0, 274, 1, 0, 0, 0, 0, 286, 1, 0, 0, 0, + 0, 288, 1, 0, 0, 0, 0, 290, 1, 0, 0, 0, 0, 292, 1, 0, 0, 0, 0, 298, 1, + 0, 0, 0, 0, 304, 1, 0, 0, 0, 0, 306, 1, 0, 0, 0, 0, 308, 1, 0, 0, 0, 0, + 310, 1, 0, 0, 0, 0, 312, 1, 0, 0, 0, 0, 314, 1, 0, 0, 0, 0, 318, 1, 0, + 0, 0, 0, 320, 1, 0, 0, 0, 0, 322, 1, 0, 0, 0, 0, 332, 1, 0, 0, 0, 0, 334, + 1, 0, 0, 0, 0, 336, 1, 0, 0, 0, 0, 338, 1, 0, 0, 0, 0, 340, 1, 0, 0, 0, + 0, 342, 1, 0, 0, 0, 0, 344, 1, 0, 0, 0, 0, 346, 1, 0, 0, 0, 0, 348, 1, + 0, 0, 0, 0, 630, 1, 0, 0, 0, 1, 350, 1, 0, 0, 0, 1, 352, 1, 0, 0, 0, 1, + 354, 1, 0, 0, 0, 1, 356, 1, 0, 0, 0, 1, 358, 1, 0, 0, 0, 2, 360, 1, 0, + 0, 0, 2, 362, 1, 0, 0, 0, 2, 364, 1, 0, 0, 0, 2, 366, 1, 0, 0, 0, 2, 368, + 1, 0, 0, 0, 3, 370, 1, 0, 0, 0, 3, 372, 1, 0, 0, 0, 3, 374, 1, 0, 0, 0, + 3, 376, 1, 0, 0, 0, 3, 378, 1, 0, 0, 0, 3, 380, 1, 0, 0, 0, 3, 382, 1, + 0, 0, 0, 3, 384, 1, 0, 0, 0, 3, 386, 1, 0, 0, 0, 3, 388, 1, 0, 0, 0, 3, + 390, 1, 0, 0, 0, 3, 392, 1, 0, 0, 0, 3, 394, 1, 0, 0, 0, 3, 396, 1, 0, + 0, 0, 3, 398, 1, 0, 0, 0, 3, 400, 1, 0, 0, 0, 3, 402, 1, 0, 0, 0, 3, 404, + 1, 0, 0, 0, 3, 406, 1, 0, 0, 0, 3, 408, 1, 0, 0, 0, 3, 410, 1, 0, 0, 0, + 3, 412, 1, 0, 0, 0, 3, 414, 1, 0, 0, 0, 3, 416, 1, 0, 0, 0, 3, 418, 1, + 0, 0, 0, 3, 420, 1, 0, 0, 0, 3, 422, 1, 0, 0, 0, 3, 424, 1, 0, 0, 0, 3, + 426, 1, 0, 0, 0, 3, 428, 1, 0, 0, 0, 3, 430, 1, 0, 0, 0, 3, 432, 1, 0, + 0, 0, 3, 434, 1, 0, 0, 0, 3, 436, 1, 0, 0, 0, 3, 438, 1, 0, 0, 0, 3, 440, + 1, 0, 0, 0, 3, 442, 1, 0, 0, 0, 3, 444, 1, 0, 0, 0, 3, 446, 1, 0, 0, 0, + 3, 448, 1, 0, 0, 0, 3, 450, 1, 0, 0, 0, 3, 452, 1, 0, 0, 0, 3, 454, 1, + 0, 0, 0, 3, 456, 1, 0, 0, 0, 3, 458, 1, 0, 0, 0, 3, 460, 1, 0, 0, 0, 3, + 462, 1, 0, 0, 0, 3, 464, 1, 0, 0, 0, 3, 466, 1, 0, 0, 0, 3, 468, 1, 0, + 0, 0, 3, 470, 1, 0, 0, 0, 3, 472, 1, 0, 0, 0, 3, 474, 1, 0, 0, 0, 3, 476, + 1, 0, 0, 0, 3, 478, 1, 0, 0, 0, 3, 480, 1, 0, 0, 0, 3, 482, 1, 0, 0, 0, + 3, 484, 1, 0, 0, 0, 3, 486, 1, 0, 0, 0, 3, 488, 1, 0, 0, 0, 3, 490, 1, + 0, 0, 0, 3, 492, 1, 0, 0, 0, 3, 494, 1, 0, 0, 0, 3, 496, 1, 0, 0, 0, 3, + 498, 1, 0, 0, 0, 3, 500, 1, 0, 0, 0, 3, 502, 1, 0, 0, 0, 3, 504, 1, 0, + 0, 0, 3, 506, 1, 0, 0, 0, 3, 508, 1, 0, 0, 0, 3, 510, 1, 0, 0, 0, 3, 512, + 1, 0, 0, 0, 3, 514, 1, 0, 0, 0, 3, 516, 1, 0, 0, 0, 3, 518, 1, 0, 0, 0, + 3, 520, 1, 0, 0, 0, 3, 522, 1, 0, 0, 0, 3, 524, 1, 0, 0, 0, 3, 526, 1, + 0, 0, 0, 3, 528, 1, 0, 0, 0, 3, 530, 1, 0, 0, 0, 3, 532, 1, 0, 0, 0, 3, + 534, 1, 0, 0, 0, 3, 536, 1, 0, 0, 0, 3, 538, 1, 0, 0, 0, 3, 540, 1, 0, + 0, 0, 3, 542, 1, 0, 0, 0, 3, 544, 1, 0, 0, 0, 3, 546, 1, 0, 0, 0, 3, 548, + 1, 0, 0, 0, 3, 550, 1, 0, 0, 0, 3, 552, 1, 0, 0, 0, 3, 554, 1, 0, 0, 0, + 3, 556, 1, 0, 0, 0, 3, 558, 1, 0, 0, 0, 3, 560, 1, 0, 0, 0, 3, 562, 1, + 0, 0, 0, 3, 564, 1, 0, 0, 0, 3, 566, 1, 0, 0, 0, 3, 568, 1, 0, 0, 0, 3, + 570, 1, 0, 0, 0, 3, 572, 1, 0, 0, 0, 3, 574, 1, 0, 0, 0, 3, 576, 1, 0, + 0, 0, 3, 578, 1, 0, 0, 0, 3, 580, 1, 0, 0, 0, 3, 582, 1, 0, 0, 0, 3, 584, + 1, 0, 0, 0, 3, 586, 1, 0, 0, 0, 3, 588, 1, 0, 0, 0, 3, 590, 1, 0, 0, 0, + 3, 592, 1, 0, 0, 0, 3, 594, 1, 0, 0, 0, 3, 596, 1, 0, 0, 0, 3, 598, 1, + 0, 0, 0, 3, 600, 1, 0, 0, 0, 3, 602, 1, 0, 0, 0, 3, 604, 1, 0, 0, 0, 3, + 606, 1, 0, 0, 0, 3, 608, 1, 0, 0, 0, 3, 610, 1, 0, 0, 0, 3, 612, 1, 0, + 0, 0, 3, 614, 1, 0, 0, 0, 3, 616, 1, 0, 0, 0, 3, 618, 1, 0, 0, 0, 3, 620, + 1, 0, 0, 0, 3, 622, 1, 0, 0, 0, 3, 624, 1, 0, 0, 0, 3, 626, 1, 0, 0, 0, + 3, 628, 1, 0, 0, 0, 4, 632, 1, 0, 0, 0, 6, 641, 1, 0, 0, 0, 8, 656, 1, + 0, 0, 0, 10, 667, 1, 0, 0, 0, 12, 676, 1, 0, 0, 0, 14, 681, 1, 0, 0, 0, + 16, 683, 1, 0, 0, 0, 18, 687, 1, 0, 0, 0, 20, 689, 1, 0, 0, 0, 22, 691, + 1, 0, 0, 0, 24, 695, 1, 0, 0, 0, 26, 697, 1, 0, 0, 0, 28, 701, 1, 0, 0, + 0, 30, 703, 1, 0, 0, 0, 32, 707, 1, 0, 0, 0, 34, 711, 1, 0, 0, 0, 36, 713, + 1, 0, 0, 0, 38, 715, 1, 0, 0, 0, 40, 717, 1, 0, 0, 0, 42, 719, 1, 0, 0, + 0, 44, 721, 1, 0, 0, 0, 46, 724, 1, 0, 0, 0, 48, 727, 1, 0, 0, 0, 50, 730, + 1, 0, 0, 0, 52, 733, 1, 0, 0, 0, 54, 736, 1, 0, 0, 0, 56, 738, 1, 0, 0, + 0, 58, 740, 1, 0, 0, 0, 60, 742, 1, 0, 0, 0, 62, 744, 1, 0, 0, 0, 64, 747, + 1, 0, 0, 0, 66, 750, 1, 0, 0, 0, 68, 753, 1, 0, 0, 0, 70, 756, 1, 0, 0, + 0, 72, 759, 1, 0, 0, 0, 74, 762, 1, 0, 0, 0, 76, 765, 1, 0, 0, 0, 78, 768, + 1, 0, 0, 0, 80, 771, 1, 0, 0, 0, 82, 774, 1, 0, 0, 0, 84, 776, 1, 0, 0, + 0, 86, 778, 1, 0, 0, 0, 88, 785, 1, 0, 0, 0, 90, 791, 1, 0, 0, 0, 92, 798, + 1, 0, 0, 0, 94, 801, 1, 0, 0, 0, 96, 803, 1, 0, 0, 0, 98, 805, 1, 0, 0, + 0, 100, 807, 1, 0, 0, 0, 102, 810, 1, 0, 0, 0, 104, 813, 1, 0, 0, 0, 106, + 816, 1, 0, 0, 0, 108, 820, 1, 0, 0, 0, 110, 824, 1, 0, 0, 0, 112, 827, + 1, 0, 0, 0, 114, 831, 1, 0, 0, 0, 116, 833, 1, 0, 0, 0, 118, 835, 1, 0, + 0, 0, 120, 845, 1, 0, 0, 0, 122, 857, 1, 0, 0, 0, 124, 866, 1, 0, 0, 0, + 126, 874, 1, 0, 0, 0, 128, 883, 1, 0, 0, 0, 130, 888, 1, 0, 0, 0, 132, + 894, 1, 0, 0, 0, 134, 903, 1, 0, 0, 0, 136, 907, 1, 0, 0, 0, 138, 911, + 1, 0, 0, 0, 140, 920, 1, 0, 0, 0, 142, 926, 1, 0, 0, 0, 144, 935, 1, 0, + 0, 0, 146, 944, 1, 0, 0, 0, 148, 952, 1, 0, 0, 0, 150, 959, 1, 0, 0, 0, + 152, 965, 1, 0, 0, 0, 154, 975, 1, 0, 0, 0, 156, 979, 1, 0, 0, 0, 158, + 986, 1, 0, 0, 0, 160, 990, 1, 0, 0, 0, 162, 994, 1, 0, 0, 0, 164, 1004, + 1, 0, 0, 0, 166, 1016, 1, 0, 0, 0, 168, 1019, 1, 0, 0, 0, 170, 1029, 1, + 0, 0, 0, 172, 1034, 1, 0, 0, 0, 174, 1039, 1, 0, 0, 0, 176, 1045, 1, 0, + 0, 0, 178, 1052, 1, 0, 0, 0, 180, 1058, 1, 0, 0, 0, 182, 1061, 1, 0, 0, + 0, 184, 1066, 1, 0, 0, 0, 186, 1071, 1, 0, 0, 0, 188, 1075, 1, 0, 0, 0, + 190, 1081, 1, 0, 0, 0, 192, 1089, 1, 0, 0, 0, 194, 1093, 1, 0, 0, 0, 196, + 1096, 1, 0, 0, 0, 198, 1102, 1, 0, 0, 0, 200, 1108, 1, 0, 0, 0, 202, 1115, + 1, 0, 0, 0, 204, 1124, 1, 0, 0, 0, 206, 1130, 1, 0, 0, 0, 208, 1133, 1, + 0, 0, 0, 210, 1136, 1, 0, 0, 0, 212, 1139, 1, 0, 0, 0, 214, 1147, 1, 0, + 0, 0, 216, 1155, 1, 0, 0, 0, 218, 1159, 1, 0, 0, 0, 220, 1167, 1, 0, 0, + 0, 222, 1174, 1, 0, 0, 0, 224, 1182, 1, 0, 0, 0, 226, 1192, 1, 0, 0, 0, + 228, 1201, 1, 0, 0, 0, 230, 1206, 1, 0, 0, 0, 232, 1213, 1, 0, 0, 0, 234, + 1224, 1, 0, 0, 0, 236, 1229, 1, 0, 0, 0, 238, 1235, 1, 0, 0, 0, 240, 1241, + 1, 0, 0, 0, 242, 1249, 1, 0, 0, 0, 244, 1258, 1, 0, 0, 0, 246, 1265, 1, + 0, 0, 0, 248, 1271, 1, 0, 0, 0, 250, 1280, 1, 0, 0, 0, 252, 1288, 1, 0, + 0, 0, 254, 1297, 1, 0, 0, 0, 256, 1306, 1, 0, 0, 0, 258, 1312, 1, 0, 0, + 0, 260, 1317, 1, 0, 0, 0, 262, 1323, 1, 0, 0, 0, 264, 1332, 1, 0, 0, 0, + 266, 1339, 1, 0, 0, 0, 268, 1348, 1, 0, 0, 0, 270, 1360, 1, 0, 0, 0, 272, + 1368, 1, 0, 0, 0, 274, 1375, 1, 0, 0, 0, 276, 1382, 1, 0, 0, 0, 278, 1384, + 1, 0, 0, 0, 280, 1388, 1, 0, 0, 0, 282, 1400, 1, 0, 0, 0, 284, 1402, 1, + 0, 0, 0, 286, 1410, 1, 0, 0, 0, 288, 1418, 1, 0, 0, 0, 290, 1431, 1, 0, + 0, 0, 292, 1443, 1, 0, 0, 0, 294, 1445, 1, 0, 0, 0, 296, 1449, 1, 0, 0, + 0, 298, 1465, 1, 0, 0, 0, 300, 1467, 1, 0, 0, 0, 302, 1471, 1, 0, 0, 0, + 304, 1487, 1, 0, 0, 0, 306, 1492, 1, 0, 0, 0, 308, 1501, 1, 0, 0, 0, 310, + 1514, 1, 0, 0, 0, 312, 1516, 1, 0, 0, 0, 314, 1521, 1, 0, 0, 0, 316, 1528, + 1, 0, 0, 0, 318, 1549, 1, 0, 0, 0, 320, 1599, 1, 0, 0, 0, 322, 1601, 1, + 0, 0, 0, 324, 1604, 1, 0, 0, 0, 326, 1611, 1, 0, 0, 0, 328, 1616, 1, 0, + 0, 0, 330, 1623, 1, 0, 0, 0, 332, 1625, 1, 0, 0, 0, 334, 1629, 1, 0, 0, + 0, 336, 1635, 1, 0, 0, 0, 338, 1637, 1, 0, 0, 0, 340, 1639, 1, 0, 0, 0, + 342, 1641, 1, 0, 0, 0, 344, 1643, 1, 0, 0, 0, 346, 1645, 1, 0, 0, 0, 348, + 1647, 1, 0, 0, 0, 350, 1649, 1, 0, 0, 0, 352, 1653, 1, 0, 0, 0, 354, 1661, + 1, 0, 0, 0, 356, 1665, 1, 0, 0, 0, 358, 1667, 1, 0, 0, 0, 360, 1673, 1, + 0, 0, 0, 362, 1682, 1, 0, 0, 0, 364, 1686, 1, 0, 0, 0, 366, 1694, 1, 0, + 0, 0, 368, 1696, 1, 0, 0, 0, 370, 1701, 1, 0, 0, 0, 372, 1706, 1, 0, 0, + 0, 374, 1711, 1, 0, 0, 0, 376, 1716, 1, 0, 0, 0, 378, 1721, 1, 0, 0, 0, + 380, 1726, 1, 0, 0, 0, 382, 1731, 1, 0, 0, 0, 384, 1735, 1, 0, 0, 0, 386, + 1739, 1, 0, 0, 0, 388, 1743, 1, 0, 0, 0, 390, 1747, 1, 0, 0, 0, 392, 1751, + 1, 0, 0, 0, 394, 1755, 1, 0, 0, 0, 396, 1759, 1, 0, 0, 0, 398, 1763, 1, + 0, 0, 0, 400, 1767, 1, 0, 0, 0, 402, 1771, 1, 0, 0, 0, 404, 1775, 1, 0, + 0, 0, 406, 1782, 1, 0, 0, 0, 408, 1786, 1, 0, 0, 0, 410, 1790, 1, 0, 0, + 0, 412, 1794, 1, 0, 0, 0, 414, 1798, 1, 0, 0, 0, 416, 1802, 1, 0, 0, 0, + 418, 1806, 1, 0, 0, 0, 420, 1810, 1, 0, 0, 0, 422, 1814, 1, 0, 0, 0, 424, + 1818, 1, 0, 0, 0, 426, 1822, 1, 0, 0, 0, 428, 1826, 1, 0, 0, 0, 430, 1830, + 1, 0, 0, 0, 432, 1834, 1, 0, 0, 0, 434, 1838, 1, 0, 0, 0, 436, 1842, 1, + 0, 0, 0, 438, 1846, 1, 0, 0, 0, 440, 1850, 1, 0, 0, 0, 442, 1854, 1, 0, + 0, 0, 444, 1858, 1, 0, 0, 0, 446, 1862, 1, 0, 0, 0, 448, 1869, 1, 0, 0, + 0, 450, 1873, 1, 0, 0, 0, 452, 1877, 1, 0, 0, 0, 454, 1881, 1, 0, 0, 0, + 456, 1885, 1, 0, 0, 0, 458, 1889, 1, 0, 0, 0, 460, 1893, 1, 0, 0, 0, 462, + 1897, 1, 0, 0, 0, 464, 1901, 1, 0, 0, 0, 466, 1905, 1, 0, 0, 0, 468, 1909, + 1, 0, 0, 0, 470, 1913, 1, 0, 0, 0, 472, 1917, 1, 0, 0, 0, 474, 1921, 1, + 0, 0, 0, 476, 1925, 1, 0, 0, 0, 478, 1929, 1, 0, 0, 0, 480, 1933, 1, 0, + 0, 0, 482, 1938, 1, 0, 0, 0, 484, 1943, 1, 0, 0, 0, 486, 1947, 1, 0, 0, + 0, 488, 1951, 1, 0, 0, 0, 490, 1955, 1, 0, 0, 0, 492, 1959, 1, 0, 0, 0, + 494, 1963, 1, 0, 0, 0, 496, 1967, 1, 0, 0, 0, 498, 1971, 1, 0, 0, 0, 500, + 1975, 1, 0, 0, 0, 502, 1979, 1, 0, 0, 0, 504, 1983, 1, 0, 0, 0, 506, 1987, + 1, 0, 0, 0, 508, 1991, 1, 0, 0, 0, 510, 1995, 1, 0, 0, 0, 512, 1999, 1, + 0, 0, 0, 514, 2003, 1, 0, 0, 0, 516, 2007, 1, 0, 0, 0, 518, 2011, 1, 0, + 0, 0, 520, 2015, 1, 0, 0, 0, 522, 2019, 1, 0, 0, 0, 524, 2023, 1, 0, 0, + 0, 526, 2027, 1, 0, 0, 0, 528, 2031, 1, 0, 0, 0, 530, 2035, 1, 0, 0, 0, + 532, 2039, 1, 0, 0, 0, 534, 2043, 1, 0, 0, 0, 536, 2047, 1, 0, 0, 0, 538, + 2051, 1, 0, 0, 0, 540, 2055, 1, 0, 0, 0, 542, 2059, 1, 0, 0, 0, 544, 2063, + 1, 0, 0, 0, 546, 2067, 1, 0, 0, 0, 548, 2071, 1, 0, 0, 0, 550, 2075, 1, + 0, 0, 0, 552, 2079, 1, 0, 0, 0, 554, 2083, 1, 0, 0, 0, 556, 2087, 1, 0, + 0, 0, 558, 2091, 1, 0, 0, 0, 560, 2095, 1, 0, 0, 0, 562, 2099, 1, 0, 0, + 0, 564, 2103, 1, 0, 0, 0, 566, 2107, 1, 0, 0, 0, 568, 2111, 1, 0, 0, 0, + 570, 2115, 1, 0, 0, 0, 572, 2119, 1, 0, 0, 0, 574, 2123, 1, 0, 0, 0, 576, + 2127, 1, 0, 0, 0, 578, 2131, 1, 0, 0, 0, 580, 2135, 1, 0, 0, 0, 582, 2139, + 1, 0, 0, 0, 584, 2143, 1, 0, 0, 0, 586, 2147, 1, 0, 0, 0, 588, 2151, 1, + 0, 0, 0, 590, 2155, 1, 0, 0, 0, 592, 2159, 1, 0, 0, 0, 594, 2163, 1, 0, + 0, 0, 596, 2167, 1, 0, 0, 0, 598, 2171, 1, 0, 0, 0, 600, 2175, 1, 0, 0, + 0, 602, 2179, 1, 0, 0, 0, 604, 2183, 1, 0, 0, 0, 606, 2187, 1, 0, 0, 0, + 608, 2191, 1, 0, 0, 0, 610, 2195, 1, 0, 0, 0, 612, 2199, 1, 0, 0, 0, 614, + 2203, 1, 0, 0, 0, 616, 2207, 1, 0, 0, 0, 618, 2211, 1, 0, 0, 0, 620, 2215, + 1, 0, 0, 0, 622, 2219, 1, 0, 0, 0, 624, 2225, 1, 0, 0, 0, 626, 2229, 1, + 0, 0, 0, 628, 2233, 1, 0, 0, 0, 630, 2237, 1, 0, 0, 0, 632, 633, 5, 35, + 0, 0, 633, 634, 5, 33, 0, 0, 634, 638, 1, 0, 0, 0, 635, 637, 8, 0, 0, 0, + 636, 635, 1, 0, 0, 0, 637, 640, 1, 0, 0, 0, 638, 636, 1, 0, 0, 0, 638, + 639, 1, 0, 0, 0, 639, 5, 1, 0, 0, 0, 640, 638, 1, 0, 0, 0, 641, 642, 5, + 47, 0, 0, 642, 643, 5, 42, 0, 0, 643, 648, 1, 0, 0, 0, 644, 647, 3, 6, + 1, 0, 645, 647, 9, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 645, 1, 0, 0, 0, + 647, 650, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, + 651, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 651, 652, 5, 42, 0, 0, 652, 653, + 5, 47, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 6, 1, 0, 0, 655, 7, 1, 0, + 0, 0, 656, 657, 5, 47, 0, 0, 657, 658, 5, 47, 0, 0, 658, 662, 1, 0, 0, + 0, 659, 661, 8, 0, 0, 0, 660, 659, 1, 0, 0, 0, 661, 664, 1, 0, 0, 0, 662, + 660, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 665, 1, 0, 0, 0, 664, 662, + 1, 0, 0, 0, 665, 666, 6, 2, 0, 0, 666, 9, 1, 0, 0, 0, 667, 668, 7, 1, 0, + 0, 668, 669, 1, 0, 0, 0, 669, 670, 6, 3, 0, 0, 670, 11, 1, 0, 0, 0, 671, + 677, 5, 10, 0, 0, 672, 674, 5, 13, 0, 0, 673, 675, 5, 10, 0, 0, 674, 673, + 1, 0, 0, 0, 674, 675, 1, 0, 0, 0, 675, 677, 1, 0, 0, 0, 676, 671, 1, 0, + 0, 0, 676, 672, 1, 0, 0, 0, 677, 13, 1, 0, 0, 0, 678, 682, 3, 6, 1, 0, + 679, 682, 3, 8, 2, 0, 680, 682, 3, 10, 3, 0, 681, 678, 1, 0, 0, 0, 681, + 679, 1, 0, 0, 0, 681, 680, 1, 0, 0, 0, 682, 15, 1, 0, 0, 0, 683, 684, 5, + 46, 0, 0, 684, 685, 5, 46, 0, 0, 685, 686, 5, 46, 0, 0, 686, 17, 1, 0, + 0, 0, 687, 688, 5, 46, 0, 0, 688, 19, 1, 0, 0, 0, 689, 690, 5, 44, 0, 0, + 690, 21, 1, 0, 0, 0, 691, 692, 5, 40, 0, 0, 692, 693, 1, 0, 0, 0, 693, + 694, 6, 9, 1, 0, 694, 23, 1, 0, 0, 0, 695, 696, 5, 41, 0, 0, 696, 25, 1, + 0, 0, 0, 697, 698, 5, 91, 0, 0, 698, 699, 1, 0, 0, 0, 699, 700, 6, 11, + 1, 0, 700, 27, 1, 0, 0, 0, 701, 702, 5, 93, 0, 0, 702, 29, 1, 0, 0, 0, + 703, 704, 5, 123, 0, 0, 704, 705, 1, 0, 0, 0, 705, 706, 6, 13, 2, 0, 706, + 31, 1, 0, 0, 0, 707, 708, 5, 125, 0, 0, 708, 709, 1, 0, 0, 0, 709, 710, + 6, 14, 3, 0, 710, 33, 1, 0, 0, 0, 711, 712, 5, 42, 0, 0, 712, 35, 1, 0, + 0, 0, 713, 714, 5, 37, 0, 0, 714, 37, 1, 0, 0, 0, 715, 716, 5, 47, 0, 0, + 716, 39, 1, 0, 0, 0, 717, 718, 5, 43, 0, 0, 718, 41, 1, 0, 0, 0, 719, 720, + 5, 45, 0, 0, 720, 43, 1, 0, 0, 0, 721, 722, 5, 43, 0, 0, 722, 723, 5, 43, + 0, 0, 723, 45, 1, 0, 0, 0, 724, 725, 5, 45, 0, 0, 725, 726, 5, 45, 0, 0, + 726, 47, 1, 0, 0, 0, 727, 728, 5, 38, 0, 0, 728, 729, 5, 38, 0, 0, 729, + 49, 1, 0, 0, 0, 730, 731, 5, 124, 0, 0, 731, 732, 5, 124, 0, 0, 732, 51, + 1, 0, 0, 0, 733, 734, 5, 33, 0, 0, 734, 735, 3, 14, 5, 0, 735, 53, 1, 0, + 0, 0, 736, 737, 5, 33, 0, 0, 737, 55, 1, 0, 0, 0, 738, 739, 5, 58, 0, 0, + 739, 57, 1, 0, 0, 0, 740, 741, 5, 59, 0, 0, 741, 59, 1, 0, 0, 0, 742, 743, + 5, 61, 0, 0, 743, 61, 1, 0, 0, 0, 744, 745, 5, 43, 0, 0, 745, 746, 5, 61, + 0, 0, 746, 63, 1, 0, 0, 0, 747, 748, 5, 45, 0, 0, 748, 749, 5, 61, 0, 0, + 749, 65, 1, 0, 0, 0, 750, 751, 5, 42, 0, 0, 751, 752, 5, 61, 0, 0, 752, + 67, 1, 0, 0, 0, 753, 754, 5, 47, 0, 0, 754, 755, 5, 61, 0, 0, 755, 69, + 1, 0, 0, 0, 756, 757, 5, 37, 0, 0, 757, 758, 5, 61, 0, 0, 758, 71, 1, 0, + 0, 0, 759, 760, 5, 45, 0, 0, 760, 761, 5, 62, 0, 0, 761, 73, 1, 0, 0, 0, + 762, 763, 5, 61, 0, 0, 763, 764, 5, 62, 0, 0, 764, 75, 1, 0, 0, 0, 765, + 766, 5, 46, 0, 0, 766, 767, 5, 46, 0, 0, 767, 77, 1, 0, 0, 0, 768, 769, + 5, 58, 0, 0, 769, 770, 5, 58, 0, 0, 770, 79, 1, 0, 0, 0, 771, 772, 5, 59, + 0, 0, 772, 773, 5, 59, 0, 0, 773, 81, 1, 0, 0, 0, 774, 775, 5, 35, 0, 0, + 775, 83, 1, 0, 0, 0, 776, 777, 5, 64, 0, 0, 777, 85, 1, 0, 0, 0, 778, 781, + 5, 64, 0, 0, 779, 782, 3, 14, 5, 0, 780, 782, 3, 12, 4, 0, 781, 779, 1, + 0, 0, 0, 781, 780, 1, 0, 0, 0, 782, 87, 1, 0, 0, 0, 783, 786, 3, 14, 5, + 0, 784, 786, 3, 12, 4, 0, 785, 783, 1, 0, 0, 0, 785, 784, 1, 0, 0, 0, 786, + 787, 1, 0, 0, 0, 787, 788, 5, 64, 0, 0, 788, 89, 1, 0, 0, 0, 789, 792, + 3, 14, 5, 0, 790, 792, 3, 12, 4, 0, 791, 789, 1, 0, 0, 0, 791, 790, 1, + 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 796, 5, 64, 0, 0, 794, 797, 3, 14, + 5, 0, 795, 797, 3, 12, 4, 0, 796, 794, 1, 0, 0, 0, 796, 795, 1, 0, 0, 0, + 797, 91, 1, 0, 0, 0, 798, 799, 5, 63, 0, 0, 799, 800, 3, 14, 5, 0, 800, + 93, 1, 0, 0, 0, 801, 802, 5, 63, 0, 0, 802, 95, 1, 0, 0, 0, 803, 804, 5, + 60, 0, 0, 804, 97, 1, 0, 0, 0, 805, 806, 5, 62, 0, 0, 806, 99, 1, 0, 0, + 0, 807, 808, 5, 60, 0, 0, 808, 809, 5, 61, 0, 0, 809, 101, 1, 0, 0, 0, + 810, 811, 5, 62, 0, 0, 811, 812, 5, 61, 0, 0, 812, 103, 1, 0, 0, 0, 813, + 814, 5, 33, 0, 0, 814, 815, 5, 61, 0, 0, 815, 105, 1, 0, 0, 0, 816, 817, + 5, 33, 0, 0, 817, 818, 5, 61, 0, 0, 818, 819, 5, 61, 0, 0, 819, 107, 1, + 0, 0, 0, 820, 821, 5, 97, 0, 0, 821, 822, 5, 115, 0, 0, 822, 823, 5, 63, + 0, 0, 823, 109, 1, 0, 0, 0, 824, 825, 5, 61, 0, 0, 825, 826, 5, 61, 0, + 0, 826, 111, 1, 0, 0, 0, 827, 828, 5, 61, 0, 0, 828, 829, 5, 61, 0, 0, + 829, 830, 5, 61, 0, 0, 830, 113, 1, 0, 0, 0, 831, 832, 5, 39, 0, 0, 832, + 115, 1, 0, 0, 0, 833, 834, 5, 38, 0, 0, 834, 117, 1, 0, 0, 0, 835, 836, + 5, 114, 0, 0, 836, 837, 5, 101, 0, 0, 837, 838, 5, 116, 0, 0, 838, 839, + 5, 117, 0, 0, 839, 840, 5, 114, 0, 0, 840, 841, 5, 110, 0, 0, 841, 842, + 5, 64, 0, 0, 842, 843, 1, 0, 0, 0, 843, 844, 3, 318, 157, 0, 844, 119, + 1, 0, 0, 0, 845, 846, 5, 99, 0, 0, 846, 847, 5, 111, 0, 0, 847, 848, 5, + 110, 0, 0, 848, 849, 5, 116, 0, 0, 849, 850, 5, 105, 0, 0, 850, 851, 5, + 110, 0, 0, 851, 852, 5, 117, 0, 0, 852, 853, 5, 101, 0, 0, 853, 854, 5, + 64, 0, 0, 854, 855, 1, 0, 0, 0, 855, 856, 3, 318, 157, 0, 856, 121, 1, + 0, 0, 0, 857, 858, 5, 98, 0, 0, 858, 859, 5, 114, 0, 0, 859, 860, 5, 101, + 0, 0, 860, 861, 5, 97, 0, 0, 861, 862, 5, 107, 0, 0, 862, 863, 5, 64, 0, + 0, 863, 864, 1, 0, 0, 0, 864, 865, 3, 318, 157, 0, 865, 123, 1, 0, 0, 0, + 866, 867, 5, 116, 0, 0, 867, 868, 5, 104, 0, 0, 868, 869, 5, 105, 0, 0, + 869, 870, 5, 115, 0, 0, 870, 871, 5, 64, 0, 0, 871, 872, 1, 0, 0, 0, 872, + 873, 3, 318, 157, 0, 873, 125, 1, 0, 0, 0, 874, 875, 5, 115, 0, 0, 875, + 876, 5, 117, 0, 0, 876, 877, 5, 112, 0, 0, 877, 878, 5, 101, 0, 0, 878, + 879, 5, 114, 0, 0, 879, 880, 5, 64, 0, 0, 880, 881, 1, 0, 0, 0, 881, 882, + 3, 318, 157, 0, 882, 127, 1, 0, 0, 0, 883, 884, 5, 102, 0, 0, 884, 885, + 5, 105, 0, 0, 885, 886, 5, 108, 0, 0, 886, 887, 5, 101, 0, 0, 887, 129, + 1, 0, 0, 0, 888, 889, 5, 102, 0, 0, 889, 890, 5, 105, 0, 0, 890, 891, 5, + 101, 0, 0, 891, 892, 5, 108, 0, 0, 892, 893, 5, 100, 0, 0, 893, 131, 1, + 0, 0, 0, 894, 895, 5, 112, 0, 0, 895, 896, 5, 114, 0, 0, 896, 897, 5, 111, + 0, 0, 897, 898, 5, 112, 0, 0, 898, 899, 5, 101, 0, 0, 899, 900, 5, 114, + 0, 0, 900, 901, 5, 116, 0, 0, 901, 902, 5, 121, 0, 0, 902, 133, 1, 0, 0, + 0, 903, 904, 5, 103, 0, 0, 904, 905, 5, 101, 0, 0, 905, 906, 5, 116, 0, + 0, 906, 135, 1, 0, 0, 0, 907, 908, 5, 115, 0, 0, 908, 909, 5, 101, 0, 0, + 909, 910, 5, 116, 0, 0, 910, 137, 1, 0, 0, 0, 911, 912, 5, 114, 0, 0, 912, + 913, 5, 101, 0, 0, 913, 914, 5, 99, 0, 0, 914, 915, 5, 101, 0, 0, 915, + 916, 5, 105, 0, 0, 916, 917, 5, 118, 0, 0, 917, 918, 5, 101, 0, 0, 918, + 919, 5, 114, 0, 0, 919, 139, 1, 0, 0, 0, 920, 921, 5, 112, 0, 0, 921, 922, + 5, 97, 0, 0, 922, 923, 5, 114, 0, 0, 923, 924, 5, 97, 0, 0, 924, 925, 5, + 109, 0, 0, 925, 141, 1, 0, 0, 0, 926, 927, 5, 115, 0, 0, 927, 928, 5, 101, + 0, 0, 928, 929, 5, 116, 0, 0, 929, 930, 5, 112, 0, 0, 930, 931, 5, 97, + 0, 0, 931, 932, 5, 114, 0, 0, 932, 933, 5, 97, 0, 0, 933, 934, 5, 109, + 0, 0, 934, 143, 1, 0, 0, 0, 935, 936, 5, 100, 0, 0, 936, 937, 5, 101, 0, + 0, 937, 938, 5, 108, 0, 0, 938, 939, 5, 101, 0, 0, 939, 940, 5, 103, 0, + 0, 940, 941, 5, 97, 0, 0, 941, 942, 5, 116, 0, 0, 942, 943, 5, 101, 0, + 0, 943, 145, 1, 0, 0, 0, 944, 945, 5, 112, 0, 0, 945, 946, 5, 97, 0, 0, + 946, 947, 5, 99, 0, 0, 947, 948, 5, 107, 0, 0, 948, 949, 5, 97, 0, 0, 949, + 950, 5, 103, 0, 0, 950, 951, 5, 101, 0, 0, 951, 147, 1, 0, 0, 0, 952, 953, + 5, 105, 0, 0, 953, 954, 5, 109, 0, 0, 954, 955, 5, 112, 0, 0, 955, 956, + 5, 111, 0, 0, 956, 957, 5, 114, 0, 0, 957, 958, 5, 116, 0, 0, 958, 149, + 1, 0, 0, 0, 959, 960, 5, 99, 0, 0, 960, 961, 5, 108, 0, 0, 961, 962, 5, + 97, 0, 0, 962, 963, 5, 115, 0, 0, 963, 964, 5, 115, 0, 0, 964, 151, 1, + 0, 0, 0, 965, 966, 5, 105, 0, 0, 966, 967, 5, 110, 0, 0, 967, 968, 5, 116, + 0, 0, 968, 969, 5, 101, 0, 0, 969, 970, 5, 114, 0, 0, 970, 971, 5, 102, + 0, 0, 971, 972, 5, 97, 0, 0, 972, 973, 5, 99, 0, 0, 973, 974, 5, 101, 0, + 0, 974, 153, 1, 0, 0, 0, 975, 976, 5, 102, 0, 0, 976, 977, 5, 117, 0, 0, + 977, 978, 5, 110, 0, 0, 978, 155, 1, 0, 0, 0, 979, 980, 5, 111, 0, 0, 980, + 981, 5, 98, 0, 0, 981, 982, 5, 106, 0, 0, 982, 983, 5, 101, 0, 0, 983, + 984, 5, 99, 0, 0, 984, 985, 5, 116, 0, 0, 985, 157, 1, 0, 0, 0, 986, 987, + 5, 118, 0, 0, 987, 988, 5, 97, 0, 0, 988, 989, 5, 108, 0, 0, 989, 159, + 1, 0, 0, 0, 990, 991, 5, 118, 0, 0, 991, 992, 5, 97, 0, 0, 992, 993, 5, + 114, 0, 0, 993, 161, 1, 0, 0, 0, 994, 995, 5, 116, 0, 0, 995, 996, 5, 121, + 0, 0, 996, 997, 5, 112, 0, 0, 997, 998, 5, 101, 0, 0, 998, 999, 5, 97, + 0, 0, 999, 1000, 5, 108, 0, 0, 1000, 1001, 5, 105, 0, 0, 1001, 1002, 5, + 97, 0, 0, 1002, 1003, 5, 115, 0, 0, 1003, 163, 1, 0, 0, 0, 1004, 1005, + 5, 99, 0, 0, 1005, 1006, 5, 111, 0, 0, 1006, 1007, 5, 110, 0, 0, 1007, + 1008, 5, 115, 0, 0, 1008, 1009, 5, 116, 0, 0, 1009, 1010, 5, 114, 0, 0, + 1010, 1011, 5, 117, 0, 0, 1011, 1012, 5, 99, 0, 0, 1012, 1013, 5, 116, + 0, 0, 1013, 1014, 5, 111, 0, 0, 1014, 1015, 5, 114, 0, 0, 1015, 165, 1, + 0, 0, 0, 1016, 1017, 5, 98, 0, 0, 1017, 1018, 5, 121, 0, 0, 1018, 167, + 1, 0, 0, 0, 1019, 1020, 5, 99, 0, 0, 1020, 1021, 5, 111, 0, 0, 1021, 1022, + 5, 109, 0, 0, 1022, 1023, 5, 112, 0, 0, 1023, 1024, 5, 97, 0, 0, 1024, + 1025, 5, 110, 0, 0, 1025, 1026, 5, 105, 0, 0, 1026, 1027, 5, 111, 0, 0, + 1027, 1028, 5, 110, 0, 0, 1028, 169, 1, 0, 0, 0, 1029, 1030, 5, 105, 0, + 0, 1030, 1031, 5, 110, 0, 0, 1031, 1032, 5, 105, 0, 0, 1032, 1033, 5, 116, + 0, 0, 1033, 171, 1, 0, 0, 0, 1034, 1035, 5, 116, 0, 0, 1035, 1036, 5, 104, + 0, 0, 1036, 1037, 5, 105, 0, 0, 1037, 1038, 5, 115, 0, 0, 1038, 173, 1, + 0, 0, 0, 1039, 1040, 5, 115, 0, 0, 1040, 1041, 5, 117, 0, 0, 1041, 1042, + 5, 112, 0, 0, 1042, 1043, 5, 101, 0, 0, 1043, 1044, 5, 114, 0, 0, 1044, + 175, 1, 0, 0, 0, 1045, 1046, 5, 116, 0, 0, 1046, 1047, 5, 121, 0, 0, 1047, + 1048, 5, 112, 0, 0, 1048, 1049, 5, 101, 0, 0, 1049, 1050, 5, 111, 0, 0, + 1050, 1051, 5, 102, 0, 0, 1051, 177, 1, 0, 0, 0, 1052, 1053, 5, 119, 0, + 0, 1053, 1054, 5, 104, 0, 0, 1054, 1055, 5, 101, 0, 0, 1055, 1056, 5, 114, + 0, 0, 1056, 1057, 5, 101, 0, 0, 1057, 179, 1, 0, 0, 0, 1058, 1059, 5, 105, + 0, 0, 1059, 1060, 5, 102, 0, 0, 1060, 181, 1, 0, 0, 0, 1061, 1062, 5, 101, + 0, 0, 1062, 1063, 5, 108, 0, 0, 1063, 1064, 5, 115, 0, 0, 1064, 1065, 5, + 101, 0, 0, 1065, 183, 1, 0, 0, 0, 1066, 1067, 5, 119, 0, 0, 1067, 1068, + 5, 104, 0, 0, 1068, 1069, 5, 101, 0, 0, 1069, 1070, 5, 110, 0, 0, 1070, + 185, 1, 0, 0, 0, 1071, 1072, 5, 116, 0, 0, 1072, 1073, 5, 114, 0, 0, 1073, + 1074, 5, 121, 0, 0, 1074, 187, 1, 0, 0, 0, 1075, 1076, 5, 99, 0, 0, 1076, + 1077, 5, 97, 0, 0, 1077, 1078, 5, 116, 0, 0, 1078, 1079, 5, 99, 0, 0, 1079, + 1080, 5, 104, 0, 0, 1080, 189, 1, 0, 0, 0, 1081, 1082, 5, 102, 0, 0, 1082, + 1083, 5, 105, 0, 0, 1083, 1084, 5, 110, 0, 0, 1084, 1085, 5, 97, 0, 0, + 1085, 1086, 5, 108, 0, 0, 1086, 1087, 5, 108, 0, 0, 1087, 1088, 5, 121, + 0, 0, 1088, 191, 1, 0, 0, 0, 1089, 1090, 5, 102, 0, 0, 1090, 1091, 5, 111, + 0, 0, 1091, 1092, 5, 114, 0, 0, 1092, 193, 1, 0, 0, 0, 1093, 1094, 5, 100, + 0, 0, 1094, 1095, 5, 111, 0, 0, 1095, 195, 1, 0, 0, 0, 1096, 1097, 5, 119, + 0, 0, 1097, 1098, 5, 104, 0, 0, 1098, 1099, 5, 105, 0, 0, 1099, 1100, 5, + 108, 0, 0, 1100, 1101, 5, 101, 0, 0, 1101, 197, 1, 0, 0, 0, 1102, 1103, + 5, 116, 0, 0, 1103, 1104, 5, 104, 0, 0, 1104, 1105, 5, 114, 0, 0, 1105, + 1106, 5, 111, 0, 0, 1106, 1107, 5, 119, 0, 0, 1107, 199, 1, 0, 0, 0, 1108, + 1109, 5, 114, 0, 0, 1109, 1110, 5, 101, 0, 0, 1110, 1111, 5, 116, 0, 0, + 1111, 1112, 5, 117, 0, 0, 1112, 1113, 5, 114, 0, 0, 1113, 1114, 5, 110, + 0, 0, 1114, 201, 1, 0, 0, 0, 1115, 1116, 5, 99, 0, 0, 1116, 1117, 5, 111, + 0, 0, 1117, 1118, 5, 110, 0, 0, 1118, 1119, 5, 116, 0, 0, 1119, 1120, 5, + 105, 0, 0, 1120, 1121, 5, 110, 0, 0, 1121, 1122, 5, 117, 0, 0, 1122, 1123, + 5, 101, 0, 0, 1123, 203, 1, 0, 0, 0, 1124, 1125, 5, 98, 0, 0, 1125, 1126, + 5, 114, 0, 0, 1126, 1127, 5, 101, 0, 0, 1127, 1128, 5, 97, 0, 0, 1128, + 1129, 5, 107, 0, 0, 1129, 205, 1, 0, 0, 0, 1130, 1131, 5, 97, 0, 0, 1131, + 1132, 5, 115, 0, 0, 1132, 207, 1, 0, 0, 0, 1133, 1134, 5, 105, 0, 0, 1134, + 1135, 5, 115, 0, 0, 1135, 209, 1, 0, 0, 0, 1136, 1137, 5, 105, 0, 0, 1137, + 1138, 5, 110, 0, 0, 1138, 211, 1, 0, 0, 0, 1139, 1140, 5, 33, 0, 0, 1140, + 1141, 5, 105, 0, 0, 1141, 1142, 5, 115, 0, 0, 1142, 1145, 1, 0, 0, 0, 1143, + 1146, 3, 14, 5, 0, 1144, 1146, 3, 12, 4, 0, 1145, 1143, 1, 0, 0, 0, 1145, + 1144, 1, 0, 0, 0, 1146, 213, 1, 0, 0, 0, 1147, 1148, 5, 33, 0, 0, 1148, + 1149, 5, 105, 0, 0, 1149, 1150, 5, 110, 0, 0, 1150, 1153, 1, 0, 0, 0, 1151, + 1154, 3, 14, 5, 0, 1152, 1154, 3, 12, 4, 0, 1153, 1151, 1, 0, 0, 0, 1153, + 1152, 1, 0, 0, 0, 1154, 215, 1, 0, 0, 0, 1155, 1156, 5, 111, 0, 0, 1156, + 1157, 5, 117, 0, 0, 1157, 1158, 5, 116, 0, 0, 1158, 217, 1, 0, 0, 0, 1159, + 1160, 5, 100, 0, 0, 1160, 1161, 5, 121, 0, 0, 1161, 1162, 5, 110, 0, 0, + 1162, 1163, 5, 97, 0, 0, 1163, 1164, 5, 109, 0, 0, 1164, 1165, 5, 105, + 0, 0, 1165, 1166, 5, 99, 0, 0, 1166, 219, 1, 0, 0, 0, 1167, 1168, 5, 112, + 0, 0, 1168, 1169, 5, 117, 0, 0, 1169, 1170, 5, 98, 0, 0, 1170, 1171, 5, + 108, 0, 0, 1171, 1172, 5, 105, 0, 0, 1172, 1173, 5, 99, 0, 0, 1173, 221, + 1, 0, 0, 0, 1174, 1175, 5, 112, 0, 0, 1175, 1176, 5, 114, 0, 0, 1176, 1177, + 5, 105, 0, 0, 1177, 1178, 5, 118, 0, 0, 1178, 1179, 5, 97, 0, 0, 1179, + 1180, 5, 116, 0, 0, 1180, 1181, 5, 101, 0, 0, 1181, 223, 1, 0, 0, 0, 1182, + 1183, 5, 112, 0, 0, 1183, 1184, 5, 114, 0, 0, 1184, 1185, 5, 111, 0, 0, + 1185, 1186, 5, 116, 0, 0, 1186, 1187, 5, 101, 0, 0, 1187, 1188, 5, 99, + 0, 0, 1188, 1189, 5, 116, 0, 0, 1189, 1190, 5, 101, 0, 0, 1190, 1191, 5, + 100, 0, 0, 1191, 225, 1, 0, 0, 0, 1192, 1193, 5, 105, 0, 0, 1193, 1194, + 5, 110, 0, 0, 1194, 1195, 5, 116, 0, 0, 1195, 1196, 5, 101, 0, 0, 1196, + 1197, 5, 114, 0, 0, 1197, 1198, 5, 110, 0, 0, 1198, 1199, 5, 97, 0, 0, + 1199, 1200, 5, 108, 0, 0, 1200, 227, 1, 0, 0, 0, 1201, 1202, 5, 101, 0, + 0, 1202, 1203, 5, 110, 0, 0, 1203, 1204, 5, 117, 0, 0, 1204, 1205, 5, 109, + 0, 0, 1205, 229, 1, 0, 0, 0, 1206, 1207, 5, 115, 0, 0, 1207, 1208, 5, 101, + 0, 0, 1208, 1209, 5, 97, 0, 0, 1209, 1210, 5, 108, 0, 0, 1210, 1211, 5, + 101, 0, 0, 1211, 1212, 5, 100, 0, 0, 1212, 231, 1, 0, 0, 0, 1213, 1214, + 5, 97, 0, 0, 1214, 1215, 5, 110, 0, 0, 1215, 1216, 5, 110, 0, 0, 1216, + 1217, 5, 111, 0, 0, 1217, 1218, 5, 116, 0, 0, 1218, 1219, 5, 97, 0, 0, + 1219, 1220, 5, 116, 0, 0, 1220, 1221, 5, 105, 0, 0, 1221, 1222, 5, 111, + 0, 0, 1222, 1223, 5, 110, 0, 0, 1223, 233, 1, 0, 0, 0, 1224, 1225, 5, 100, + 0, 0, 1225, 1226, 5, 97, 0, 0, 1226, 1227, 5, 116, 0, 0, 1227, 1228, 5, + 97, 0, 0, 1228, 235, 1, 0, 0, 0, 1229, 1230, 5, 105, 0, 0, 1230, 1231, + 5, 110, 0, 0, 1231, 1232, 5, 110, 0, 0, 1232, 1233, 5, 101, 0, 0, 1233, + 1234, 5, 114, 0, 0, 1234, 237, 1, 0, 0, 0, 1235, 1236, 5, 118, 0, 0, 1236, + 1237, 5, 97, 0, 0, 1237, 1238, 5, 108, 0, 0, 1238, 1239, 5, 117, 0, 0, + 1239, 1240, 5, 101, 0, 0, 1240, 239, 1, 0, 0, 0, 1241, 1242, 5, 116, 0, + 0, 1242, 1243, 5, 97, 0, 0, 1243, 1244, 5, 105, 0, 0, 1244, 1245, 5, 108, + 0, 0, 1245, 1246, 5, 114, 0, 0, 1246, 1247, 5, 101, 0, 0, 1247, 1248, 5, + 99, 0, 0, 1248, 241, 1, 0, 0, 0, 1249, 1250, 5, 111, 0, 0, 1250, 1251, + 5, 112, 0, 0, 1251, 1252, 5, 101, 0, 0, 1252, 1253, 5, 114, 0, 0, 1253, + 1254, 5, 97, 0, 0, 1254, 1255, 5, 116, 0, 0, 1255, 1256, 5, 111, 0, 0, + 1256, 1257, 5, 114, 0, 0, 1257, 243, 1, 0, 0, 0, 1258, 1259, 5, 105, 0, + 0, 1259, 1260, 5, 110, 0, 0, 1260, 1261, 5, 108, 0, 0, 1261, 1262, 5, 105, + 0, 0, 1262, 1263, 5, 110, 0, 0, 1263, 1264, 5, 101, 0, 0, 1264, 245, 1, + 0, 0, 0, 1265, 1266, 5, 105, 0, 0, 1266, 1267, 5, 110, 0, 0, 1267, 1268, + 5, 102, 0, 0, 1268, 1269, 5, 105, 0, 0, 1269, 1270, 5, 120, 0, 0, 1270, + 247, 1, 0, 0, 0, 1271, 1272, 5, 101, 0, 0, 1272, 1273, 5, 120, 0, 0, 1273, + 1274, 5, 116, 0, 0, 1274, 1275, 5, 101, 0, 0, 1275, 1276, 5, 114, 0, 0, + 1276, 1277, 5, 110, 0, 0, 1277, 1278, 5, 97, 0, 0, 1278, 1279, 5, 108, + 0, 0, 1279, 249, 1, 0, 0, 0, 1280, 1281, 5, 115, 0, 0, 1281, 1282, 5, 117, + 0, 0, 1282, 1283, 5, 115, 0, 0, 1283, 1284, 5, 112, 0, 0, 1284, 1285, 5, + 101, 0, 0, 1285, 1286, 5, 110, 0, 0, 1286, 1287, 5, 100, 0, 0, 1287, 251, + 1, 0, 0, 0, 1288, 1289, 5, 111, 0, 0, 1289, 1290, 5, 118, 0, 0, 1290, 1291, + 5, 101, 0, 0, 1291, 1292, 5, 114, 0, 0, 1292, 1293, 5, 114, 0, 0, 1293, + 1294, 5, 105, 0, 0, 1294, 1295, 5, 100, 0, 0, 1295, 1296, 5, 101, 0, 0, + 1296, 253, 1, 0, 0, 0, 1297, 1298, 5, 97, 0, 0, 1298, 1299, 5, 98, 0, 0, + 1299, 1300, 5, 115, 0, 0, 1300, 1301, 5, 116, 0, 0, 1301, 1302, 5, 114, + 0, 0, 1302, 1303, 5, 97, 0, 0, 1303, 1304, 5, 99, 0, 0, 1304, 1305, 5, + 116, 0, 0, 1305, 255, 1, 0, 0, 0, 1306, 1307, 5, 102, 0, 0, 1307, 1308, + 5, 105, 0, 0, 1308, 1309, 5, 110, 0, 0, 1309, 1310, 5, 97, 0, 0, 1310, + 1311, 5, 108, 0, 0, 1311, 257, 1, 0, 0, 0, 1312, 1313, 5, 111, 0, 0, 1313, + 1314, 5, 112, 0, 0, 1314, 1315, 5, 101, 0, 0, 1315, 1316, 5, 110, 0, 0, + 1316, 259, 1, 0, 0, 0, 1317, 1318, 5, 99, 0, 0, 1318, 1319, 5, 111, 0, + 0, 1319, 1320, 5, 110, 0, 0, 1320, 1321, 5, 115, 0, 0, 1321, 1322, 5, 116, + 0, 0, 1322, 261, 1, 0, 0, 0, 1323, 1324, 5, 108, 0, 0, 1324, 1325, 5, 97, + 0, 0, 1325, 1326, 5, 116, 0, 0, 1326, 1327, 5, 101, 0, 0, 1327, 1328, 5, + 105, 0, 0, 1328, 1329, 5, 110, 0, 0, 1329, 1330, 5, 105, 0, 0, 1330, 1331, + 5, 116, 0, 0, 1331, 263, 1, 0, 0, 0, 1332, 1333, 5, 118, 0, 0, 1333, 1334, + 5, 97, 0, 0, 1334, 1335, 5, 114, 0, 0, 1335, 1336, 5, 97, 0, 0, 1336, 1337, + 5, 114, 0, 0, 1337, 1338, 5, 103, 0, 0, 1338, 265, 1, 0, 0, 0, 1339, 1340, + 5, 110, 0, 0, 1340, 1341, 5, 111, 0, 0, 1341, 1342, 5, 105, 0, 0, 1342, + 1343, 5, 110, 0, 0, 1343, 1344, 5, 108, 0, 0, 1344, 1345, 5, 105, 0, 0, + 1345, 1346, 5, 110, 0, 0, 1346, 1347, 5, 101, 0, 0, 1347, 267, 1, 0, 0, + 0, 1348, 1349, 5, 99, 0, 0, 1349, 1350, 5, 114, 0, 0, 1350, 1351, 5, 111, + 0, 0, 1351, 1352, 5, 115, 0, 0, 1352, 1353, 5, 115, 0, 0, 1353, 1354, 5, + 105, 0, 0, 1354, 1355, 5, 110, 0, 0, 1355, 1356, 5, 108, 0, 0, 1356, 1357, + 5, 105, 0, 0, 1357, 1358, 5, 110, 0, 0, 1358, 1359, 5, 101, 0, 0, 1359, + 269, 1, 0, 0, 0, 1360, 1361, 5, 114, 0, 0, 1361, 1362, 5, 101, 0, 0, 1362, + 1363, 5, 105, 0, 0, 1363, 1364, 5, 102, 0, 0, 1364, 1365, 5, 105, 0, 0, + 1365, 1366, 5, 101, 0, 0, 1366, 1367, 5, 100, 0, 0, 1367, 271, 1, 0, 0, + 0, 1368, 1369, 5, 101, 0, 0, 1369, 1370, 5, 120, 0, 0, 1370, 1371, 5, 112, + 0, 0, 1371, 1372, 5, 101, 0, 0, 1372, 1373, 5, 99, 0, 0, 1373, 1374, 5, + 116, 0, 0, 1374, 273, 1, 0, 0, 0, 1375, 1376, 5, 97, 0, 0, 1376, 1377, + 5, 99, 0, 0, 1377, 1378, 5, 116, 0, 0, 1378, 1379, 5, 117, 0, 0, 1379, + 1380, 5, 97, 0, 0, 1380, 1381, 5, 108, 0, 0, 1381, 275, 1, 0, 0, 0, 1382, + 1383, 2, 48, 57, 0, 1383, 277, 1, 0, 0, 0, 1384, 1385, 2, 49, 57, 0, 1385, + 279, 1, 0, 0, 0, 1386, 1389, 3, 276, 136, 0, 1387, 1389, 5, 95, 0, 0, 1388, + 1386, 1, 0, 0, 0, 1388, 1387, 1, 0, 0, 0, 1389, 281, 1, 0, 0, 0, 1390, + 1394, 3, 276, 136, 0, 1391, 1393, 3, 280, 138, 0, 1392, 1391, 1, 0, 0, + 0, 1393, 1396, 1, 0, 0, 0, 1394, 1392, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, + 0, 1395, 1397, 1, 0, 0, 0, 1396, 1394, 1, 0, 0, 0, 1397, 1398, 3, 276, + 136, 0, 1398, 1401, 1, 0, 0, 0, 1399, 1401, 3, 276, 136, 0, 1400, 1390, + 1, 0, 0, 0, 1400, 1399, 1, 0, 0, 0, 1401, 283, 1, 0, 0, 0, 1402, 1404, + 7, 2, 0, 0, 1403, 1405, 7, 3, 0, 0, 1404, 1403, 1, 0, 0, 0, 1404, 1405, + 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1407, 3, 282, 139, 0, 1407, 285, + 1, 0, 0, 0, 1408, 1411, 3, 288, 142, 0, 1409, 1411, 3, 290, 143, 0, 1410, + 1408, 1, 0, 0, 0, 1410, 1409, 1, 0, 0, 0, 1411, 287, 1, 0, 0, 0, 1412, + 1413, 3, 290, 143, 0, 1413, 1414, 7, 4, 0, 0, 1414, 1419, 1, 0, 0, 0, 1415, + 1416, 3, 282, 139, 0, 1416, 1417, 7, 4, 0, 0, 1417, 1419, 1, 0, 0, 0, 1418, + 1412, 1, 0, 0, 0, 1418, 1415, 1, 0, 0, 0, 1419, 289, 1, 0, 0, 0, 1420, + 1422, 3, 282, 139, 0, 1421, 1420, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, + 1423, 1, 0, 0, 0, 1423, 1424, 5, 46, 0, 0, 1424, 1426, 3, 282, 139, 0, + 1425, 1427, 3, 284, 140, 0, 1426, 1425, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, + 0, 1427, 1432, 1, 0, 0, 0, 1428, 1429, 3, 282, 139, 0, 1429, 1430, 3, 284, + 140, 0, 1430, 1432, 1, 0, 0, 0, 1431, 1421, 1, 0, 0, 0, 1431, 1428, 1, + 0, 0, 0, 1432, 291, 1, 0, 0, 0, 1433, 1437, 3, 278, 137, 0, 1434, 1436, + 3, 280, 138, 0, 1435, 1434, 1, 0, 0, 0, 1436, 1439, 1, 0, 0, 0, 1437, 1435, + 1, 0, 0, 0, 1437, 1438, 1, 0, 0, 0, 1438, 1440, 1, 0, 0, 0, 1439, 1437, + 1, 0, 0, 0, 1440, 1441, 3, 276, 136, 0, 1441, 1444, 1, 0, 0, 0, 1442, 1444, + 3, 276, 136, 0, 1443, 1433, 1, 0, 0, 0, 1443, 1442, 1, 0, 0, 0, 1444, 293, + 1, 0, 0, 0, 1445, 1446, 7, 5, 0, 0, 1446, 295, 1, 0, 0, 0, 1447, 1450, + 3, 294, 145, 0, 1448, 1450, 5, 95, 0, 0, 1449, 1447, 1, 0, 0, 0, 1449, + 1448, 1, 0, 0, 0, 1450, 297, 1, 0, 0, 0, 1451, 1452, 5, 48, 0, 0, 1452, + 1453, 7, 6, 0, 0, 1453, 1457, 3, 294, 145, 0, 1454, 1456, 3, 296, 146, + 0, 1455, 1454, 1, 0, 0, 0, 1456, 1459, 1, 0, 0, 0, 1457, 1455, 1, 0, 0, + 0, 1457, 1458, 1, 0, 0, 0, 1458, 1460, 1, 0, 0, 0, 1459, 1457, 1, 0, 0, + 0, 1460, 1461, 3, 294, 145, 0, 1461, 1466, 1, 0, 0, 0, 1462, 1463, 5, 48, + 0, 0, 1463, 1464, 7, 6, 0, 0, 1464, 1466, 3, 294, 145, 0, 1465, 1451, 1, + 0, 0, 0, 1465, 1462, 1, 0, 0, 0, 1466, 299, 1, 0, 0, 0, 1467, 1468, 7, + 7, 0, 0, 1468, 301, 1, 0, 0, 0, 1469, 1472, 3, 300, 148, 0, 1470, 1472, + 5, 95, 0, 0, 1471, 1469, 1, 0, 0, 0, 1471, 1470, 1, 0, 0, 0, 1472, 303, + 1, 0, 0, 0, 1473, 1474, 5, 48, 0, 0, 1474, 1475, 7, 8, 0, 0, 1475, 1479, + 3, 300, 148, 0, 1476, 1478, 3, 302, 149, 0, 1477, 1476, 1, 0, 0, 0, 1478, + 1481, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1479, 1480, 1, 0, 0, 0, 1480, + 1482, 1, 0, 0, 0, 1481, 1479, 1, 0, 0, 0, 1482, 1483, 3, 300, 148, 0, 1483, + 1488, 1, 0, 0, 0, 1484, 1485, 5, 48, 0, 0, 1485, 1486, 7, 8, 0, 0, 1486, + 1488, 3, 300, 148, 0, 1487, 1473, 1, 0, 0, 0, 1487, 1484, 1, 0, 0, 0, 1488, + 305, 1, 0, 0, 0, 1489, 1493, 3, 292, 144, 0, 1490, 1493, 3, 298, 147, 0, + 1491, 1493, 3, 304, 150, 0, 1492, 1489, 1, 0, 0, 0, 1492, 1490, 1, 0, 0, + 0, 1492, 1491, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 1496, 7, 9, 0, + 0, 1495, 1497, 7, 10, 0, 0, 1496, 1495, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, + 0, 1497, 307, 1, 0, 0, 0, 1498, 1502, 3, 292, 144, 0, 1499, 1502, 3, 298, + 147, 0, 1500, 1502, 3, 304, 150, 0, 1501, 1498, 1, 0, 0, 0, 1501, 1499, + 1, 0, 0, 0, 1501, 1500, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 1504, + 7, 10, 0, 0, 1504, 309, 1, 0, 0, 0, 1505, 1506, 5, 116, 0, 0, 1506, 1507, + 5, 114, 0, 0, 1507, 1508, 5, 117, 0, 0, 1508, 1515, 5, 101, 0, 0, 1509, + 1510, 5, 102, 0, 0, 1510, 1511, 5, 97, 0, 0, 1511, 1512, 5, 108, 0, 0, + 1512, 1513, 5, 115, 0, 0, 1513, 1515, 5, 101, 0, 0, 1514, 1505, 1, 0, 0, + 0, 1514, 1509, 1, 0, 0, 0, 1515, 311, 1, 0, 0, 0, 1516, 1517, 5, 110, 0, + 0, 1517, 1518, 5, 117, 0, 0, 1518, 1519, 5, 108, 0, 0, 1519, 1520, 5, 108, + 0, 0, 1520, 313, 1, 0, 0, 0, 1521, 1524, 5, 39, 0, 0, 1522, 1525, 3, 328, + 162, 0, 1523, 1525, 8, 11, 0, 0, 1524, 1522, 1, 0, 0, 0, 1524, 1523, 1, + 0, 0, 0, 1525, 1526, 1, 0, 0, 0, 1526, 1527, 5, 39, 0, 0, 1527, 315, 1, + 0, 0, 0, 1528, 1529, 3, 346, 171, 0, 1529, 317, 1, 0, 0, 0, 1530, 1533, + 3, 330, 163, 0, 1531, 1533, 5, 95, 0, 0, 1532, 1530, 1, 0, 0, 0, 1532, + 1531, 1, 0, 0, 0, 1533, 1539, 1, 0, 0, 0, 1534, 1538, 3, 330, 163, 0, 1535, + 1538, 5, 95, 0, 0, 1536, 1538, 3, 316, 156, 0, 1537, 1534, 1, 0, 0, 0, + 1537, 1535, 1, 0, 0, 0, 1537, 1536, 1, 0, 0, 0, 1538, 1541, 1, 0, 0, 0, + 1539, 1537, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1550, 1, 0, 0, 0, + 1541, 1539, 1, 0, 0, 0, 1542, 1544, 5, 96, 0, 0, 1543, 1545, 8, 12, 0, + 0, 1544, 1543, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1544, 1, 0, 0, + 0, 1546, 1547, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 1550, 5, 96, 0, + 0, 1549, 1532, 1, 0, 0, 0, 1549, 1542, 1, 0, 0, 0, 1550, 319, 1, 0, 0, + 0, 1551, 1600, 3, 318, 157, 0, 1552, 1600, 3, 254, 125, 0, 1553, 1600, + 3, 232, 114, 0, 1554, 1600, 3, 166, 81, 0, 1555, 1600, 3, 188, 92, 0, 1556, + 1600, 3, 168, 82, 0, 1557, 1600, 3, 164, 80, 0, 1558, 1600, 3, 268, 132, + 0, 1559, 1600, 3, 234, 115, 0, 1560, 1600, 3, 218, 107, 0, 1561, 1600, + 3, 228, 112, 0, 1562, 1600, 3, 248, 122, 0, 1563, 1600, 3, 256, 126, 0, + 1564, 1600, 3, 190, 93, 0, 1565, 1600, 3, 148, 72, 0, 1566, 1600, 3, 246, + 121, 0, 1567, 1600, 3, 170, 83, 0, 1568, 1600, 3, 244, 120, 0, 1569, 1600, + 3, 236, 116, 0, 1570, 1600, 3, 226, 111, 0, 1571, 1600, 3, 262, 129, 0, + 1572, 1600, 3, 266, 131, 0, 1573, 1600, 3, 258, 127, 0, 1574, 1600, 3, + 242, 119, 0, 1575, 1600, 3, 216, 106, 0, 1576, 1600, 3, 252, 124, 0, 1577, + 1600, 3, 222, 109, 0, 1578, 1600, 3, 224, 110, 0, 1579, 1600, 3, 220, 108, + 0, 1580, 1600, 3, 270, 133, 0, 1581, 1600, 3, 230, 113, 0, 1582, 1600, + 3, 240, 118, 0, 1583, 1600, 3, 264, 130, 0, 1584, 1600, 3, 178, 87, 0, + 1585, 1600, 3, 134, 65, 0, 1586, 1600, 3, 136, 66, 0, 1587, 1600, 3, 130, + 63, 0, 1588, 1600, 3, 132, 64, 0, 1589, 1600, 3, 138, 67, 0, 1590, 1600, + 3, 140, 68, 0, 1591, 1600, 3, 142, 69, 0, 1592, 1600, 3, 144, 70, 0, 1593, + 1600, 3, 128, 62, 0, 1594, 1600, 3, 272, 134, 0, 1595, 1600, 3, 274, 135, + 0, 1596, 1600, 3, 238, 117, 0, 1597, 1600, 3, 260, 128, 0, 1598, 1600, + 3, 250, 123, 0, 1599, 1551, 1, 0, 0, 0, 1599, 1552, 1, 0, 0, 0, 1599, 1553, + 1, 0, 0, 0, 1599, 1554, 1, 0, 0, 0, 1599, 1555, 1, 0, 0, 0, 1599, 1556, + 1, 0, 0, 0, 1599, 1557, 1, 0, 0, 0, 1599, 1558, 1, 0, 0, 0, 1599, 1559, + 1, 0, 0, 0, 1599, 1560, 1, 0, 0, 0, 1599, 1561, 1, 0, 0, 0, 1599, 1562, + 1, 0, 0, 0, 1599, 1563, 1, 0, 0, 0, 1599, 1564, 1, 0, 0, 0, 1599, 1565, + 1, 0, 0, 0, 1599, 1566, 1, 0, 0, 0, 1599, 1567, 1, 0, 0, 0, 1599, 1568, + 1, 0, 0, 0, 1599, 1569, 1, 0, 0, 0, 1599, 1570, 1, 0, 0, 0, 1599, 1571, + 1, 0, 0, 0, 1599, 1572, 1, 0, 0, 0, 1599, 1573, 1, 0, 0, 0, 1599, 1574, + 1, 0, 0, 0, 1599, 1575, 1, 0, 0, 0, 1599, 1576, 1, 0, 0, 0, 1599, 1577, + 1, 0, 0, 0, 1599, 1578, 1, 0, 0, 0, 1599, 1579, 1, 0, 0, 0, 1599, 1580, + 1, 0, 0, 0, 1599, 1581, 1, 0, 0, 0, 1599, 1582, 1, 0, 0, 0, 1599, 1583, + 1, 0, 0, 0, 1599, 1584, 1, 0, 0, 0, 1599, 1585, 1, 0, 0, 0, 1599, 1586, + 1, 0, 0, 0, 1599, 1587, 1, 0, 0, 0, 1599, 1588, 1, 0, 0, 0, 1599, 1589, + 1, 0, 0, 0, 1599, 1590, 1, 0, 0, 0, 1599, 1591, 1, 0, 0, 0, 1599, 1592, + 1, 0, 0, 0, 1599, 1593, 1, 0, 0, 0, 1599, 1594, 1, 0, 0, 0, 1599, 1595, + 1, 0, 0, 0, 1599, 1596, 1, 0, 0, 0, 1599, 1597, 1, 0, 0, 0, 1599, 1598, + 1, 0, 0, 0, 1600, 321, 1, 0, 0, 0, 1601, 1602, 5, 36, 0, 0, 1602, 1603, + 3, 320, 158, 0, 1603, 323, 1, 0, 0, 0, 1604, 1605, 5, 92, 0, 0, 1605, 1606, + 5, 117, 0, 0, 1606, 1607, 3, 294, 145, 0, 1607, 1608, 3, 294, 145, 0, 1608, + 1609, 3, 294, 145, 0, 1609, 1610, 3, 294, 145, 0, 1610, 325, 1, 0, 0, 0, + 1611, 1612, 5, 92, 0, 0, 1612, 1613, 7, 13, 0, 0, 1613, 327, 1, 0, 0, 0, + 1614, 1617, 3, 324, 160, 0, 1615, 1617, 3, 326, 161, 0, 1616, 1614, 1, + 0, 0, 0, 1616, 1615, 1, 0, 0, 0, 1617, 329, 1, 0, 0, 0, 1618, 1624, 3, + 344, 170, 0, 1619, 1624, 3, 336, 166, 0, 1620, 1624, 3, 342, 169, 0, 1621, + 1624, 3, 338, 167, 0, 1622, 1624, 3, 340, 168, 0, 1623, 1618, 1, 0, 0, + 0, 1623, 1619, 1, 0, 0, 0, 1623, 1620, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, + 0, 1623, 1622, 1, 0, 0, 0, 1624, 331, 1, 0, 0, 0, 1625, 1626, 5, 34, 0, + 0, 1626, 1627, 1, 0, 0, 0, 1627, 1628, 6, 164, 4, 0, 1628, 333, 1, 0, 0, + 0, 1629, 1630, 5, 34, 0, 0, 1630, 1631, 5, 34, 0, 0, 1631, 1632, 5, 34, + 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634, 6, 165, 5, 0, 1634, 335, 1, 0, + 0, 0, 1635, 1636, 7, 14, 0, 0, 1636, 337, 1, 0, 0, 0, 1637, 1638, 7, 15, + 0, 0, 1638, 339, 1, 0, 0, 0, 1639, 1640, 7, 16, 0, 0, 1640, 341, 1, 0, + 0, 0, 1641, 1642, 7, 17, 0, 0, 1642, 343, 1, 0, 0, 0, 1643, 1644, 7, 18, + 0, 0, 1644, 345, 1, 0, 0, 0, 1645, 1646, 7, 19, 0, 0, 1646, 347, 1, 0, + 0, 0, 1647, 1648, 7, 20, 0, 0, 1648, 349, 1, 0, 0, 0, 1649, 1650, 5, 34, + 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1652, 6, 173, 3, 0, 1652, 351, 1, 0, + 0, 0, 1653, 1654, 3, 322, 159, 0, 1654, 353, 1, 0, 0, 0, 1655, 1657, 8, + 21, 0, 0, 1656, 1655, 1, 0, 0, 0, 1657, 1658, 1, 0, 0, 0, 1658, 1656, 1, + 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1662, 1, 0, 0, 0, 1660, 1662, 5, + 36, 0, 0, 1661, 1656, 1, 0, 0, 0, 1661, 1660, 1, 0, 0, 0, 1662, 355, 1, + 0, 0, 0, 1663, 1666, 3, 326, 161, 0, 1664, 1666, 3, 324, 160, 0, 1665, + 1663, 1, 0, 0, 0, 1665, 1664, 1, 0, 0, 0, 1666, 357, 1, 0, 0, 0, 1667, + 1668, 5, 36, 0, 0, 1668, 1669, 5, 123, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, + 1671, 6, 177, 2, 0, 1671, 359, 1, 0, 0, 0, 1672, 1674, 3, 362, 179, 0, + 1673, 1672, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, + 1675, 1676, 5, 34, 0, 0, 1676, 1677, 5, 34, 0, 0, 1677, 1678, 5, 34, 0, + 0, 1678, 1679, 1, 0, 0, 0, 1679, 1680, 6, 178, 3, 0, 1680, 361, 1, 0, 0, + 0, 1681, 1683, 5, 34, 0, 0, 1682, 1681, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, + 0, 1684, 1682, 1, 0, 0, 0, 1684, 1685, 1, 0, 0, 0, 1685, 363, 1, 0, 0, + 0, 1686, 1687, 3, 322, 159, 0, 1687, 365, 1, 0, 0, 0, 1688, 1690, 8, 22, + 0, 0, 1689, 1688, 1, 0, 0, 0, 1690, 1691, 1, 0, 0, 0, 1691, 1689, 1, 0, + 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1695, 5, 36, + 0, 0, 1694, 1689, 1, 0, 0, 0, 1694, 1693, 1, 0, 0, 0, 1695, 367, 1, 0, + 0, 0, 1696, 1697, 5, 36, 0, 0, 1697, 1698, 5, 123, 0, 0, 1698, 1699, 1, + 0, 0, 0, 1699, 1700, 6, 182, 2, 0, 1700, 369, 1, 0, 0, 0, 1701, 1702, 3, + 24, 10, 0, 1702, 1703, 1, 0, 0, 0, 1703, 1704, 6, 183, 3, 0, 1704, 1705, + 6, 183, 6, 0, 1705, 371, 1, 0, 0, 0, 1706, 1707, 3, 28, 12, 0, 1707, 1708, + 1, 0, 0, 0, 1708, 1709, 6, 184, 3, 0, 1709, 1710, 6, 184, 7, 0, 1710, 373, + 1, 0, 0, 0, 1711, 1712, 3, 22, 9, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1714, + 6, 185, 1, 0, 1714, 1715, 6, 185, 8, 0, 1715, 375, 1, 0, 0, 0, 1716, 1717, + 3, 26, 11, 0, 1717, 1718, 1, 0, 0, 0, 1718, 1719, 6, 186, 1, 0, 1719, 1720, + 6, 186, 9, 0, 1720, 377, 1, 0, 0, 0, 1721, 1722, 3, 30, 13, 0, 1722, 1723, + 1, 0, 0, 0, 1723, 1724, 6, 187, 2, 0, 1724, 1725, 6, 187, 10, 0, 1725, + 379, 1, 0, 0, 0, 1726, 1727, 3, 32, 14, 0, 1727, 1728, 1, 0, 0, 0, 1728, + 1729, 6, 188, 3, 0, 1729, 1730, 6, 188, 11, 0, 1730, 381, 1, 0, 0, 0, 1731, + 1732, 3, 18, 7, 0, 1732, 1733, 1, 0, 0, 0, 1733, 1734, 6, 189, 12, 0, 1734, + 383, 1, 0, 0, 0, 1735, 1736, 3, 20, 8, 0, 1736, 1737, 1, 0, 0, 0, 1737, + 1738, 6, 190, 13, 0, 1738, 385, 1, 0, 0, 0, 1739, 1740, 3, 34, 15, 0, 1740, + 1741, 1, 0, 0, 0, 1741, 1742, 6, 191, 14, 0, 1742, 387, 1, 0, 0, 0, 1743, + 1744, 3, 36, 16, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1746, 6, 192, 15, 0, + 1746, 389, 1, 0, 0, 0, 1747, 1748, 3, 38, 17, 0, 1748, 1749, 1, 0, 0, 0, + 1749, 1750, 6, 193, 16, 0, 1750, 391, 1, 0, 0, 0, 1751, 1752, 3, 40, 18, + 0, 1752, 1753, 1, 0, 0, 0, 1753, 1754, 6, 194, 17, 0, 1754, 393, 1, 0, + 0, 0, 1755, 1756, 3, 42, 19, 0, 1756, 1757, 1, 0, 0, 0, 1757, 1758, 6, + 195, 18, 0, 1758, 395, 1, 0, 0, 0, 1759, 1760, 3, 44, 20, 0, 1760, 1761, + 1, 0, 0, 0, 1761, 1762, 6, 196, 19, 0, 1762, 397, 1, 0, 0, 0, 1763, 1764, + 3, 46, 21, 0, 1764, 1765, 1, 0, 0, 0, 1765, 1766, 6, 197, 20, 0, 1766, + 399, 1, 0, 0, 0, 1767, 1768, 3, 48, 22, 0, 1768, 1769, 1, 0, 0, 0, 1769, + 1770, 6, 198, 21, 0, 1770, 401, 1, 0, 0, 0, 1771, 1772, 3, 50, 23, 0, 1772, + 1773, 1, 0, 0, 0, 1773, 1774, 6, 199, 22, 0, 1774, 403, 1, 0, 0, 0, 1775, + 1778, 5, 33, 0, 0, 1776, 1779, 3, 14, 5, 0, 1777, 1779, 3, 12, 4, 0, 1778, + 1776, 1, 0, 0, 0, 1778, 1777, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, + 1781, 6, 200, 23, 0, 1781, 405, 1, 0, 0, 0, 1782, 1783, 3, 54, 25, 0, 1783, + 1784, 1, 0, 0, 0, 1784, 1785, 6, 201, 24, 0, 1785, 407, 1, 0, 0, 0, 1786, + 1787, 3, 56, 26, 0, 1787, 1788, 1, 0, 0, 0, 1788, 1789, 6, 202, 25, 0, + 1789, 409, 1, 0, 0, 0, 1790, 1791, 3, 58, 27, 0, 1791, 1792, 1, 0, 0, 0, + 1792, 1793, 6, 203, 26, 0, 1793, 411, 1, 0, 0, 0, 1794, 1795, 3, 60, 28, + 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 6, 204, 27, 0, 1797, 413, 1, 0, + 0, 0, 1798, 1799, 3, 62, 29, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1801, 6, + 205, 28, 0, 1801, 415, 1, 0, 0, 0, 1802, 1803, 3, 64, 30, 0, 1803, 1804, + 1, 0, 0, 0, 1804, 1805, 6, 206, 29, 0, 1805, 417, 1, 0, 0, 0, 1806, 1807, + 3, 66, 31, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1809, 6, 207, 30, 0, 1809, + 419, 1, 0, 0, 0, 1810, 1811, 3, 68, 32, 0, 1811, 1812, 1, 0, 0, 0, 1812, + 1813, 6, 208, 31, 0, 1813, 421, 1, 0, 0, 0, 1814, 1815, 3, 70, 33, 0, 1815, + 1816, 1, 0, 0, 0, 1816, 1817, 6, 209, 32, 0, 1817, 423, 1, 0, 0, 0, 1818, + 1819, 3, 72, 34, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1821, 6, 210, 33, 0, + 1821, 425, 1, 0, 0, 0, 1822, 1823, 3, 74, 35, 0, 1823, 1824, 1, 0, 0, 0, + 1824, 1825, 6, 211, 34, 0, 1825, 427, 1, 0, 0, 0, 1826, 1827, 3, 76, 36, + 0, 1827, 1828, 1, 0, 0, 0, 1828, 1829, 6, 212, 35, 0, 1829, 429, 1, 0, + 0, 0, 1830, 1831, 3, 16, 6, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1833, 6, 213, + 36, 0, 1833, 431, 1, 0, 0, 0, 1834, 1835, 3, 78, 37, 0, 1835, 1836, 1, + 0, 0, 0, 1836, 1837, 6, 214, 37, 0, 1837, 433, 1, 0, 0, 0, 1838, 1839, + 3, 80, 38, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1841, 6, 215, 38, 0, 1841, + 435, 1, 0, 0, 0, 1842, 1843, 3, 82, 39, 0, 1843, 1844, 1, 0, 0, 0, 1844, + 1845, 6, 216, 39, 0, 1845, 437, 1, 0, 0, 0, 1846, 1847, 3, 84, 40, 0, 1847, + 1848, 1, 0, 0, 0, 1848, 1849, 6, 217, 40, 0, 1849, 439, 1, 0, 0, 0, 1850, + 1851, 3, 86, 41, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1853, 6, 218, 41, 0, + 1853, 441, 1, 0, 0, 0, 1854, 1855, 3, 88, 42, 0, 1855, 1856, 1, 0, 0, 0, + 1856, 1857, 6, 219, 42, 0, 1857, 443, 1, 0, 0, 0, 1858, 1859, 3, 90, 43, + 0, 1859, 1860, 1, 0, 0, 0, 1860, 1861, 6, 220, 43, 0, 1861, 445, 1, 0, + 0, 0, 1862, 1865, 5, 63, 0, 0, 1863, 1866, 3, 14, 5, 0, 1864, 1866, 3, + 12, 4, 0, 1865, 1863, 1, 0, 0, 0, 1865, 1864, 1, 0, 0, 0, 1866, 1867, 1, + 0, 0, 0, 1867, 1868, 6, 221, 44, 0, 1868, 447, 1, 0, 0, 0, 1869, 1870, + 3, 94, 45, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1872, 6, 222, 45, 0, 1872, + 449, 1, 0, 0, 0, 1873, 1874, 3, 96, 46, 0, 1874, 1875, 1, 0, 0, 0, 1875, + 1876, 6, 223, 46, 0, 1876, 451, 1, 0, 0, 0, 1877, 1878, 3, 98, 47, 0, 1878, + 1879, 1, 0, 0, 0, 1879, 1880, 6, 224, 47, 0, 1880, 453, 1, 0, 0, 0, 1881, + 1882, 3, 100, 48, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1884, 6, 225, 48, 0, + 1884, 455, 1, 0, 0, 0, 1885, 1886, 3, 102, 49, 0, 1886, 1887, 1, 0, 0, + 0, 1887, 1888, 6, 226, 49, 0, 1888, 457, 1, 0, 0, 0, 1889, 1890, 3, 104, + 50, 0, 1890, 1891, 1, 0, 0, 0, 1891, 1892, 6, 227, 50, 0, 1892, 459, 1, + 0, 0, 0, 1893, 1894, 3, 106, 51, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1896, + 6, 228, 51, 0, 1896, 461, 1, 0, 0, 0, 1897, 1898, 3, 208, 102, 0, 1898, + 1899, 1, 0, 0, 0, 1899, 1900, 6, 229, 52, 0, 1900, 463, 1, 0, 0, 0, 1901, + 1902, 3, 212, 104, 0, 1902, 1903, 1, 0, 0, 0, 1903, 1904, 6, 230, 53, 0, + 1904, 465, 1, 0, 0, 0, 1905, 1906, 3, 214, 105, 0, 1906, 1907, 1, 0, 0, + 0, 1907, 1908, 6, 231, 54, 0, 1908, 467, 1, 0, 0, 0, 1909, 1910, 3, 206, + 101, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1912, 6, 232, 55, 0, 1912, 469, 1, + 0, 0, 0, 1913, 1914, 3, 108, 52, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1916, + 6, 233, 56, 0, 1916, 471, 1, 0, 0, 0, 1917, 1918, 3, 110, 53, 0, 1918, + 1919, 1, 0, 0, 0, 1919, 1920, 6, 234, 57, 0, 1920, 473, 1, 0, 0, 0, 1921, + 1922, 3, 112, 54, 0, 1922, 1923, 1, 0, 0, 0, 1923, 1924, 6, 235, 58, 0, + 1924, 475, 1, 0, 0, 0, 1925, 1926, 3, 114, 55, 0, 1926, 1927, 1, 0, 0, + 0, 1927, 1928, 6, 236, 59, 0, 1928, 477, 1, 0, 0, 0, 1929, 1930, 3, 116, + 56, 0, 1930, 1931, 1, 0, 0, 0, 1931, 1932, 6, 237, 60, 0, 1932, 479, 1, + 0, 0, 0, 1933, 1934, 3, 332, 164, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1936, + 6, 238, 4, 0, 1936, 1937, 6, 238, 61, 0, 1937, 481, 1, 0, 0, 0, 1938, 1939, + 3, 334, 165, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1941, 6, 239, 5, 0, 1941, + 1942, 6, 239, 62, 0, 1942, 483, 1, 0, 0, 0, 1943, 1944, 3, 158, 77, 0, + 1944, 1945, 1, 0, 0, 0, 1945, 1946, 6, 240, 63, 0, 1946, 485, 1, 0, 0, + 0, 1947, 1948, 3, 160, 78, 0, 1948, 1949, 1, 0, 0, 0, 1949, 1950, 6, 241, + 64, 0, 1950, 487, 1, 0, 0, 0, 1951, 1952, 3, 154, 75, 0, 1952, 1953, 1, + 0, 0, 0, 1953, 1954, 6, 242, 65, 0, 1954, 489, 1, 0, 0, 0, 1955, 1956, + 3, 156, 76, 0, 1956, 1957, 1, 0, 0, 0, 1957, 1958, 6, 243, 66, 0, 1958, + 491, 1, 0, 0, 0, 1959, 1960, 3, 174, 85, 0, 1960, 1961, 1, 0, 0, 0, 1961, + 1962, 6, 244, 67, 0, 1962, 493, 1, 0, 0, 0, 1963, 1964, 3, 210, 103, 0, + 1964, 1965, 1, 0, 0, 0, 1965, 1966, 6, 245, 68, 0, 1966, 495, 1, 0, 0, + 0, 1967, 1968, 3, 216, 106, 0, 1968, 1969, 1, 0, 0, 0, 1969, 1970, 6, 246, + 69, 0, 1970, 497, 1, 0, 0, 0, 1971, 1972, 3, 130, 63, 0, 1972, 1973, 1, + 0, 0, 0, 1973, 1974, 6, 247, 70, 0, 1974, 499, 1, 0, 0, 0, 1975, 1976, + 3, 128, 62, 0, 1976, 1977, 1, 0, 0, 0, 1977, 1978, 6, 248, 71, 0, 1978, + 501, 1, 0, 0, 0, 1979, 1980, 3, 132, 64, 0, 1980, 1981, 1, 0, 0, 0, 1981, + 1982, 6, 249, 72, 0, 1982, 503, 1, 0, 0, 0, 1983, 1984, 3, 134, 65, 0, + 1984, 1985, 1, 0, 0, 0, 1985, 1986, 6, 250, 73, 0, 1986, 505, 1, 0, 0, + 0, 1987, 1988, 3, 136, 66, 0, 1988, 1989, 1, 0, 0, 0, 1989, 1990, 6, 251, + 74, 0, 1990, 507, 1, 0, 0, 0, 1991, 1992, 3, 138, 67, 0, 1992, 1993, 1, + 0, 0, 0, 1993, 1994, 6, 252, 75, 0, 1994, 509, 1, 0, 0, 0, 1995, 1996, + 3, 140, 68, 0, 1996, 1997, 1, 0, 0, 0, 1997, 1998, 6, 253, 76, 0, 1998, + 511, 1, 0, 0, 0, 1999, 2000, 3, 142, 69, 0, 2000, 2001, 1, 0, 0, 0, 2001, + 2002, 6, 254, 77, 0, 2002, 513, 1, 0, 0, 0, 2003, 2004, 3, 144, 70, 0, + 2004, 2005, 1, 0, 0, 0, 2005, 2006, 6, 255, 78, 0, 2006, 515, 1, 0, 0, + 0, 2007, 2008, 3, 198, 97, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2010, 6, 256, + 79, 0, 2010, 517, 1, 0, 0, 0, 2011, 2012, 3, 200, 98, 0, 2012, 2013, 1, + 0, 0, 0, 2013, 2014, 6, 257, 80, 0, 2014, 519, 1, 0, 0, 0, 2015, 2016, + 3, 202, 99, 0, 2016, 2017, 1, 0, 0, 0, 2017, 2018, 6, 258, 81, 0, 2018, + 521, 1, 0, 0, 0, 2019, 2020, 3, 204, 100, 0, 2020, 2021, 1, 0, 0, 0, 2021, + 2022, 6, 259, 82, 0, 2022, 523, 1, 0, 0, 0, 2023, 2024, 3, 118, 57, 0, + 2024, 2025, 1, 0, 0, 0, 2025, 2026, 6, 260, 83, 0, 2026, 525, 1, 0, 0, + 0, 2027, 2028, 3, 120, 58, 0, 2028, 2029, 1, 0, 0, 0, 2029, 2030, 6, 261, + 84, 0, 2030, 527, 1, 0, 0, 0, 2031, 2032, 3, 122, 59, 0, 2032, 2033, 1, + 0, 0, 0, 2033, 2034, 6, 262, 85, 0, 2034, 529, 1, 0, 0, 0, 2035, 2036, + 3, 180, 88, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2038, 6, 263, 86, 0, 2038, + 531, 1, 0, 0, 0, 2039, 2040, 3, 182, 89, 0, 2040, 2041, 1, 0, 0, 0, 2041, + 2042, 6, 264, 87, 0, 2042, 533, 1, 0, 0, 0, 2043, 2044, 3, 184, 90, 0, + 2044, 2045, 1, 0, 0, 0, 2045, 2046, 6, 265, 88, 0, 2046, 535, 1, 0, 0, + 0, 2047, 2048, 3, 186, 91, 0, 2048, 2049, 1, 0, 0, 0, 2049, 2050, 6, 266, + 89, 0, 2050, 537, 1, 0, 0, 0, 2051, 2052, 3, 188, 92, 0, 2052, 2053, 1, + 0, 0, 0, 2053, 2054, 6, 267, 90, 0, 2054, 539, 1, 0, 0, 0, 2055, 2056, + 3, 190, 93, 0, 2056, 2057, 1, 0, 0, 0, 2057, 2058, 6, 268, 91, 0, 2058, + 541, 1, 0, 0, 0, 2059, 2060, 3, 192, 94, 0, 2060, 2061, 1, 0, 0, 0, 2061, + 2062, 6, 269, 92, 0, 2062, 543, 1, 0, 0, 0, 2063, 2064, 3, 194, 95, 0, + 2064, 2065, 1, 0, 0, 0, 2065, 2066, 6, 270, 93, 0, 2066, 545, 1, 0, 0, + 0, 2067, 2068, 3, 196, 96, 0, 2068, 2069, 1, 0, 0, 0, 2069, 2070, 6, 271, + 94, 0, 2070, 547, 1, 0, 0, 0, 2071, 2072, 3, 220, 108, 0, 2072, 2073, 1, + 0, 0, 0, 2073, 2074, 6, 272, 95, 0, 2074, 549, 1, 0, 0, 0, 2075, 2076, + 3, 222, 109, 0, 2076, 2077, 1, 0, 0, 0, 2077, 2078, 6, 273, 96, 0, 2078, + 551, 1, 0, 0, 0, 2079, 2080, 3, 224, 110, 0, 2080, 2081, 1, 0, 0, 0, 2081, + 2082, 6, 274, 97, 0, 2082, 553, 1, 0, 0, 0, 2083, 2084, 3, 226, 111, 0, + 2084, 2085, 1, 0, 0, 0, 2085, 2086, 6, 275, 98, 0, 2086, 555, 1, 0, 0, + 0, 2087, 2088, 3, 228, 112, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2090, 6, 276, + 99, 0, 2090, 557, 1, 0, 0, 0, 2091, 2092, 3, 230, 113, 0, 2092, 2093, 1, + 0, 0, 0, 2093, 2094, 6, 277, 100, 0, 2094, 559, 1, 0, 0, 0, 2095, 2096, + 3, 232, 114, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2098, 6, 278, 101, 0, 2098, + 561, 1, 0, 0, 0, 2099, 2100, 3, 234, 115, 0, 2100, 2101, 1, 0, 0, 0, 2101, + 2102, 6, 279, 102, 0, 2102, 563, 1, 0, 0, 0, 2103, 2104, 3, 236, 116, 0, + 2104, 2105, 1, 0, 0, 0, 2105, 2106, 6, 280, 103, 0, 2106, 565, 1, 0, 0, + 0, 2107, 2108, 3, 238, 117, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2110, 6, 281, + 104, 0, 2110, 567, 1, 0, 0, 0, 2111, 2112, 3, 240, 118, 0, 2112, 2113, + 1, 0, 0, 0, 2113, 2114, 6, 282, 105, 0, 2114, 569, 1, 0, 0, 0, 2115, 2116, + 3, 242, 119, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2118, 6, 283, 106, 0, 2118, + 571, 1, 0, 0, 0, 2119, 2120, 3, 244, 120, 0, 2120, 2121, 1, 0, 0, 0, 2121, + 2122, 6, 284, 107, 0, 2122, 573, 1, 0, 0, 0, 2123, 2124, 3, 246, 121, 0, + 2124, 2125, 1, 0, 0, 0, 2125, 2126, 6, 285, 108, 0, 2126, 575, 1, 0, 0, + 0, 2127, 2128, 3, 248, 122, 0, 2128, 2129, 1, 0, 0, 0, 2129, 2130, 6, 286, + 109, 0, 2130, 577, 1, 0, 0, 0, 2131, 2132, 3, 250, 123, 0, 2132, 2133, + 1, 0, 0, 0, 2133, 2134, 6, 287, 110, 0, 2134, 579, 1, 0, 0, 0, 2135, 2136, + 3, 252, 124, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2138, 6, 288, 111, 0, 2138, + 581, 1, 0, 0, 0, 2139, 2140, 3, 254, 125, 0, 2140, 2141, 1, 0, 0, 0, 2141, + 2142, 6, 289, 112, 0, 2142, 583, 1, 0, 0, 0, 2143, 2144, 3, 256, 126, 0, + 2144, 2145, 1, 0, 0, 0, 2145, 2146, 6, 290, 113, 0, 2146, 585, 1, 0, 0, + 0, 2147, 2148, 3, 258, 127, 0, 2148, 2149, 1, 0, 0, 0, 2149, 2150, 6, 291, + 114, 0, 2150, 587, 1, 0, 0, 0, 2151, 2152, 3, 260, 128, 0, 2152, 2153, + 1, 0, 0, 0, 2153, 2154, 6, 292, 115, 0, 2154, 589, 1, 0, 0, 0, 2155, 2156, + 3, 262, 129, 0, 2156, 2157, 1, 0, 0, 0, 2157, 2158, 6, 293, 116, 0, 2158, + 591, 1, 0, 0, 0, 2159, 2160, 3, 264, 130, 0, 2160, 2161, 1, 0, 0, 0, 2161, + 2162, 6, 294, 117, 0, 2162, 593, 1, 0, 0, 0, 2163, 2164, 3, 266, 131, 0, + 2164, 2165, 1, 0, 0, 0, 2165, 2166, 6, 295, 118, 0, 2166, 595, 1, 0, 0, + 0, 2167, 2168, 3, 268, 132, 0, 2168, 2169, 1, 0, 0, 0, 2169, 2170, 6, 296, + 119, 0, 2170, 597, 1, 0, 0, 0, 2171, 2172, 3, 270, 133, 0, 2172, 2173, + 1, 0, 0, 0, 2173, 2174, 6, 297, 120, 0, 2174, 599, 1, 0, 0, 0, 2175, 2176, + 3, 272, 134, 0, 2176, 2177, 1, 0, 0, 0, 2177, 2178, 6, 298, 121, 0, 2178, + 601, 1, 0, 0, 0, 2179, 2180, 3, 274, 135, 0, 2180, 2181, 1, 0, 0, 0, 2181, + 2182, 6, 299, 122, 0, 2182, 603, 1, 0, 0, 0, 2183, 2184, 3, 310, 153, 0, + 2184, 2185, 1, 0, 0, 0, 2185, 2186, 6, 300, 123, 0, 2186, 605, 1, 0, 0, + 0, 2187, 2188, 3, 292, 144, 0, 2188, 2189, 1, 0, 0, 0, 2189, 2190, 6, 301, + 124, 0, 2190, 607, 1, 0, 0, 0, 2191, 2192, 3, 298, 147, 0, 2192, 2193, + 1, 0, 0, 0, 2193, 2194, 6, 302, 125, 0, 2194, 609, 1, 0, 0, 0, 2195, 2196, + 3, 304, 150, 0, 2196, 2197, 1, 0, 0, 0, 2197, 2198, 6, 303, 126, 0, 2198, + 611, 1, 0, 0, 0, 2199, 2200, 3, 314, 155, 0, 2200, 2201, 1, 0, 0, 0, 2201, + 2202, 6, 304, 127, 0, 2202, 613, 1, 0, 0, 0, 2203, 2204, 3, 286, 141, 0, + 2204, 2205, 1, 0, 0, 0, 2205, 2206, 6, 305, 128, 0, 2206, 615, 1, 0, 0, + 0, 2207, 2208, 3, 312, 154, 0, 2208, 2209, 1, 0, 0, 0, 2209, 2210, 6, 306, + 129, 0, 2210, 617, 1, 0, 0, 0, 2211, 2212, 3, 308, 152, 0, 2212, 2213, + 1, 0, 0, 0, 2213, 2214, 6, 307, 130, 0, 2214, 619, 1, 0, 0, 0, 2215, 2216, + 3, 306, 151, 0, 2216, 2217, 1, 0, 0, 0, 2217, 2218, 6, 308, 131, 0, 2218, + 621, 1, 0, 0, 0, 2219, 2220, 3, 318, 157, 0, 2220, 2221, 1, 0, 0, 0, 2221, + 2222, 6, 309, 132, 0, 2222, 623, 1, 0, 0, 0, 2223, 2226, 3, 8, 2, 0, 2224, + 2226, 3, 6, 1, 0, 2225, 2223, 1, 0, 0, 0, 2225, 2224, 1, 0, 0, 0, 2226, + 2227, 1, 0, 0, 0, 2227, 2228, 6, 310, 0, 0, 2228, 625, 1, 0, 0, 0, 2229, + 2230, 3, 10, 3, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2232, 6, 311, 0, 0, 2232, + 627, 1, 0, 0, 0, 2233, 2234, 3, 12, 4, 0, 2234, 2235, 1, 0, 0, 0, 2235, + 2236, 6, 312, 0, 0, 2236, 629, 1, 0, 0, 0, 2237, 2238, 9, 0, 0, 0, 2238, + 631, 1, 0, 0, 0, 57, 0, 1, 2, 3, 638, 646, 648, 662, 674, 676, 681, 781, + 785, 791, 796, 1145, 1153, 1388, 1394, 1400, 1404, 1410, 1418, 1421, 1426, + 1431, 1437, 1443, 1449, 1457, 1465, 1471, 1479, 1487, 1492, 1496, 1501, + 1514, 1524, 1532, 1537, 1539, 1546, 1549, 1599, 1616, 1623, 1658, 1661, + 1665, 1673, 1684, 1691, 1694, 1778, 1865, 2225, 133, 0, 1, 0, 5, 3, 0, + 5, 0, 0, 4, 0, 0, 5, 1, 0, 5, 2, 0, 7, 10, 0, 7, 12, 0, 7, 9, 0, 7, 11, + 0, 7, 13, 0, 7, 14, 0, 7, 7, 0, 7, 8, 0, 7, 15, 0, 7, 16, 0, 7, 17, 0, + 7, 18, 0, 7, 19, 0, 7, 20, 0, 7, 21, 0, 7, 22, 0, 7, 23, 0, 7, 24, 0, 7, + 25, 0, 7, 26, 0, 7, 27, 0, 7, 28, 0, 7, 29, 0, 7, 30, 0, 7, 31, 0, 7, 32, + 0, 7, 33, 0, 7, 34, 0, 7, 35, 0, 7, 36, 0, 7, 6, 0, 7, 37, 0, 7, 38, 0, + 7, 39, 0, 7, 40, 0, 7, 41, 0, 7, 42, 0, 7, 43, 0, 7, 44, 0, 7, 45, 0, 7, + 46, 0, 7, 47, 0, 7, 48, 0, 7, 49, 0, 7, 50, 0, 7, 51, 0, 7, 102, 0, 7, + 104, 0, 7, 105, 0, 7, 101, 0, 7, 52, 0, 7, 53, 0, 7, 54, 0, 7, 55, 0, 7, + 56, 0, 7, 150, 0, 7, 151, 0, 7, 77, 0, 7, 78, 0, 7, 75, 0, 7, 76, 0, 7, + 85, 0, 7, 103, 0, 7, 106, 0, 7, 63, 0, 7, 62, 0, 7, 64, 0, 7, 65, 0, 7, + 66, 0, 7, 67, 0, 7, 68, 0, 7, 69, 0, 7, 70, 0, 7, 97, 0, 7, 98, 0, 7, 99, + 0, 7, 100, 0, 7, 57, 0, 7, 58, 0, 7, 59, 0, 7, 88, 0, 7, 89, 0, 7, 90, + 0, 7, 91, 0, 7, 92, 0, 7, 93, 0, 7, 94, 0, 7, 95, 0, 7, 96, 0, 7, 108, + 0, 7, 109, 0, 7, 110, 0, 7, 111, 0, 7, 112, 0, 7, 113, 0, 7, 114, 0, 7, + 115, 0, 7, 116, 0, 7, 117, 0, 7, 118, 0, 7, 119, 0, 7, 120, 0, 7, 121, + 0, 7, 122, 0, 7, 123, 0, 7, 124, 0, 7, 125, 0, 7, 126, 0, 7, 127, 0, 7, + 128, 0, 7, 129, 0, 7, 130, 0, 7, 131, 0, 7, 132, 0, 7, 133, 0, 7, 134, + 0, 7, 135, 0, 7, 144, 0, 7, 139, 0, 7, 140, 0, 7, 141, 0, 7, 146, 0, 7, + 136, 0, 7, 145, 0, 7, 143, 0, 7, 142, 0, 7, 147, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// KotlinLexerInit initializes any static state used to implement KotlinLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewKotlinLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func KotlinLexerInit() { + staticData := &kotlinlexerLexerStaticData + staticData.once.Do(kotlinlexerLexerInit) +} + +// NewKotlinLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewKotlinLexer(input antlr.CharStream) *KotlinLexer { + KotlinLexerInit() + l := new(KotlinLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &kotlinlexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.predictionContextCache) + l.channelNames = staticData.channelNames + l.modeNames = staticData.modeNames + l.RuleNames = staticData.ruleNames + l.LiteralNames = staticData.literalNames + l.SymbolicNames = staticData.symbolicNames + l.GrammarFileName = "KotlinLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// KotlinLexer tokens. +const ( + KotlinLexerShebangLine = 1 + KotlinLexerDelimitedComment = 2 + KotlinLexerLineComment = 3 + KotlinLexerWS = 4 + KotlinLexerNL = 5 + KotlinLexerRESERVED = 6 + KotlinLexerDOT = 7 + KotlinLexerCOMMA = 8 + KotlinLexerLPAREN = 9 + KotlinLexerRPAREN = 10 + KotlinLexerLSQUARE = 11 + KotlinLexerRSQUARE = 12 + KotlinLexerLCURL = 13 + KotlinLexerRCURL = 14 + KotlinLexerMULT = 15 + KotlinLexerMOD = 16 + KotlinLexerDIV = 17 + KotlinLexerADD = 18 + KotlinLexerSUB = 19 + KotlinLexerINCR = 20 + KotlinLexerDECR = 21 + KotlinLexerCONJ = 22 + KotlinLexerDISJ = 23 + KotlinLexerEXCL_WS = 24 + KotlinLexerEXCL_NO_WS = 25 + KotlinLexerCOLON = 26 + KotlinLexerSEMICOLON = 27 + KotlinLexerASSIGNMENT = 28 + KotlinLexerADD_ASSIGNMENT = 29 + KotlinLexerSUB_ASSIGNMENT = 30 + KotlinLexerMULT_ASSIGNMENT = 31 + KotlinLexerDIV_ASSIGNMENT = 32 + KotlinLexerMOD_ASSIGNMENT = 33 + KotlinLexerARROW = 34 + KotlinLexerDOUBLE_ARROW = 35 + KotlinLexerRANGE = 36 + KotlinLexerCOLONCOLON = 37 + KotlinLexerDOUBLE_SEMICOLON = 38 + KotlinLexerHASH = 39 + KotlinLexerAT_NO_WS = 40 + KotlinLexerAT_POST_WS = 41 + KotlinLexerAT_PRE_WS = 42 + KotlinLexerAT_BOTH_WS = 43 + KotlinLexerQUEST_WS = 44 + KotlinLexerQUEST_NO_WS = 45 + KotlinLexerLANGLE = 46 + KotlinLexerRANGLE = 47 + KotlinLexerLE = 48 + KotlinLexerGE = 49 + KotlinLexerEXCL_EQ = 50 + KotlinLexerEXCL_EQEQ = 51 + KotlinLexerAS_SAFE = 52 + KotlinLexerEQEQ = 53 + KotlinLexerEQEQEQ = 54 + KotlinLexerSINGLE_QUOTE = 55 + KotlinLexerAMP = 56 + KotlinLexerRETURN_AT = 57 + KotlinLexerCONTINUE_AT = 58 + KotlinLexerBREAK_AT = 59 + KotlinLexerTHIS_AT = 60 + KotlinLexerSUPER_AT = 61 + KotlinLexerFILE = 62 + KotlinLexerFIELD = 63 + KotlinLexerPROPERTY = 64 + KotlinLexerGET = 65 + KotlinLexerSET = 66 + KotlinLexerRECEIVER = 67 + KotlinLexerPARAM = 68 + KotlinLexerSETPARAM = 69 + KotlinLexerDELEGATE = 70 + KotlinLexerPACKAGE = 71 + KotlinLexerIMPORT = 72 + KotlinLexerCLASS = 73 + KotlinLexerINTERFACE = 74 + KotlinLexerFUN = 75 + KotlinLexerOBJECT = 76 + KotlinLexerVAL = 77 + KotlinLexerVAR = 78 + KotlinLexerTYPE_ALIAS = 79 + KotlinLexerCONSTRUCTOR = 80 + KotlinLexerBY = 81 + KotlinLexerCOMPANION = 82 + KotlinLexerINIT = 83 + KotlinLexerTHIS = 84 + KotlinLexerSUPER = 85 + KotlinLexerTYPEOF = 86 + KotlinLexerWHERE = 87 + KotlinLexerIF = 88 + KotlinLexerELSE = 89 + KotlinLexerWHEN = 90 + KotlinLexerTRY = 91 + KotlinLexerCATCH = 92 + KotlinLexerFINALLY = 93 + KotlinLexerFOR = 94 + KotlinLexerDO = 95 + KotlinLexerWHILE = 96 + KotlinLexerTHROW = 97 + KotlinLexerRETURN = 98 + KotlinLexerCONTINUE = 99 + KotlinLexerBREAK = 100 + KotlinLexerAS = 101 + KotlinLexerIS = 102 + KotlinLexerIN = 103 + KotlinLexerNOT_IS = 104 + KotlinLexerNOT_IN = 105 + KotlinLexerOUT = 106 + KotlinLexerDYNAMIC = 107 + KotlinLexerPUBLIC = 108 + KotlinLexerPRIVATE = 109 + KotlinLexerPROTECTED = 110 + KotlinLexerINTERNAL = 111 + KotlinLexerENUM = 112 + KotlinLexerSEALED = 113 + KotlinLexerANNOTATION = 114 + KotlinLexerDATA = 115 + KotlinLexerINNER = 116 + KotlinLexerVALUE = 117 + KotlinLexerTAILREC = 118 + KotlinLexerOPERATOR = 119 + KotlinLexerINLINE = 120 + KotlinLexerINFIX = 121 + KotlinLexerEXTERNAL = 122 + KotlinLexerSUSPEND = 123 + KotlinLexerOVERRIDE = 124 + KotlinLexerABSTRACT = 125 + KotlinLexerFINAL = 126 + KotlinLexerOPEN = 127 + KotlinLexerCONST = 128 + KotlinLexerLATEINIT = 129 + KotlinLexerVARARG = 130 + KotlinLexerNOINLINE = 131 + KotlinLexerCROSSINLINE = 132 + KotlinLexerREIFIED = 133 + KotlinLexerEXPECT = 134 + KotlinLexerACTUAL = 135 + KotlinLexerRealLiteral = 136 + KotlinLexerFloatLiteral = 137 + KotlinLexerDoubleLiteral = 138 + KotlinLexerIntegerLiteral = 139 + KotlinLexerHexLiteral = 140 + KotlinLexerBinLiteral = 141 + KotlinLexerUnsignedLiteral = 142 + KotlinLexerLongLiteral = 143 + KotlinLexerBooleanLiteral = 144 + KotlinLexerNullLiteral = 145 + KotlinLexerCharacterLiteral = 146 + KotlinLexerIdentifier = 147 + KotlinLexerIdentifierOrSoftKey = 148 + KotlinLexerFieldIdentifier = 149 + KotlinLexerQUOTE_OPEN = 150 + KotlinLexerTRIPLE_QUOTE_OPEN = 151 + KotlinLexerUNICODE_CLASS_LL = 152 + KotlinLexerUNICODE_CLASS_LM = 153 + KotlinLexerUNICODE_CLASS_LO = 154 + KotlinLexerUNICODE_CLASS_LT = 155 + KotlinLexerUNICODE_CLASS_LU = 156 + KotlinLexerUNICODE_CLASS_ND = 157 + KotlinLexerUNICODE_CLASS_NL = 158 + KotlinLexerQUOTE_CLOSE = 159 + KotlinLexerLineStrRef = 160 + KotlinLexerLineStrText = 161 + KotlinLexerLineStrEscapedChar = 162 + KotlinLexerLineStrExprStart = 163 + KotlinLexerTRIPLE_QUOTE_CLOSE = 164 + KotlinLexerMultiLineStringQuote = 165 + KotlinLexerMultiLineStrRef = 166 + KotlinLexerMultiLineStrText = 167 + KotlinLexerMultiLineStrExprStart = 168 + KotlinLexerInside_Comment = 169 + KotlinLexerInside_WS = 170 + KotlinLexerInside_NL = 171 + KotlinLexerErrorCharacter = 172 +) + +// KotlinLexer modes. +const ( + KotlinLexerLineString = iota + 1 + KotlinLexerMultiLineString + KotlinLexerInside +) diff --git a/lib/archer/kotlin_parser/kotlin_parser.go b/lib/archer/kotlin_parser/kotlin_parser.go new file mode 100644 index 0000000..1e6cf75 --- /dev/null +++ b/lib/archer/kotlin_parser/kotlin_parser.go @@ -0,0 +1,37008 @@ +// Code generated from java-escape by ANTLR 4.11.1. DO NOT EDIT. + +package kotlin_parser // KotlinParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr/antlr4/runtime/Go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type KotlinParser struct { + *antlr.BaseParser +} + +var kotlinparserParserStaticData struct { + once sync.Once + serializedATN []int32 + literalNames []string + symbolicNames []string + ruleNames []string + predictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func kotlinparserParserInit() { + staticData := &kotlinparserParserStaticData + staticData.literalNames = []string{ + "", "", "", "", "", "", "'...'", "'.'", "','", "'('", "')'", "'['", + "']'", "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", "'--'", + "'&&'", "'||'", "", "'!'", "':'", "';'", "'='", "'+='", "'-='", "'*='", + "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "';;'", "'#'", "'@'", + "", "", "", "", "'?'", "'<'", "'>'", "'<='", "'>='", "'!='", "'!=='", + "'as?'", "'=='", "'==='", "'''", "'&'", "", "", "", "", "", "'file'", + "'field'", "'property'", "'get'", "'set'", "'receiver'", "'param'", + "'setparam'", "'delegate'", "'package'", "'import'", "'class'", "'interface'", + "'fun'", "'object'", "'val'", "'var'", "'typealias'", "'constructor'", + "'by'", "'companion'", "'init'", "'this'", "'super'", "'typeof'", "'where'", + "'if'", "'else'", "'when'", "'try'", "'catch'", "'finally'", "'for'", + "'do'", "'while'", "'throw'", "'return'", "'continue'", "'break'", "'as'", + "'is'", "'in'", "", "", "'out'", "'dynamic'", "'public'", "'private'", + "'protected'", "'internal'", "'enum'", "'sealed'", "'annotation'", "'data'", + "'inner'", "'value'", "'tailrec'", "'operator'", "'inline'", "'infix'", + "'external'", "'suspend'", "'override'", "'abstract'", "'final'", "'open'", + "'const'", "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", + "'reified'", "'expect'", "'actual'", "", "", "", "", "", "", "", "", + "", "'null'", "", "", "", "", "", "'\"\"\"'", + } + staticData.symbolicNames = []string{ + "", "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", + "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", + "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", + "EXCL_WS", "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", + "SUB_ASSIGNMENT", "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", + "ARROW", "DOUBLE_ARROW", "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", + "HASH", "AT_NO_WS", "AT_POST_WS", "AT_PRE_WS", "AT_BOTH_WS", "QUEST_WS", + "QUEST_NO_WS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", + "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "AMP", "RETURN_AT", "CONTINUE_AT", + "BREAK_AT", "THIS_AT", "SUPER_AT", "FILE", "FIELD", "PROPERTY", "GET", + "SET", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", "PACKAGE", "IMPORT", + "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", + "BY", "COMPANION", "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", + "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", + "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", + "OUT", "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", + "SEALED", "ANNOTATION", "DATA", "INNER", "VALUE", "TAILREC", "OPERATOR", + "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", + "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", + "EXPECT", "ACTUAL", "RealLiteral", "FloatLiteral", "DoubleLiteral", + "IntegerLiteral", "HexLiteral", "BinLiteral", "UnsignedLiteral", "LongLiteral", + "BooleanLiteral", "NullLiteral", "CharacterLiteral", "Identifier", "IdentifierOrSoftKey", + "FieldIdentifier", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "QUOTE_CLOSE", "LineStrRef", + "LineStrText", "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", "MultiLineStrExprStart", + "Inside_Comment", "Inside_WS", "Inside_NL", "ErrorCharacter", + } + staticData.ruleNames = []string{ + "kotlinFile", "script", "shebangLine", "fileAnnotation", "packageHeader", + "importList", "importHeader", "importAlias", "topLevelObject", "typeAlias", + "declaration", "classDeclaration", "primaryConstructor", "classBody", + "classParameters", "classParameter", "delegationSpecifiers", "delegationSpecifier", + "constructorInvocation", "annotatedDelegationSpecifier", "explicitDelegation", + "typeParameters", "typeParameter", "typeConstraints", "typeConstraint", + "classMemberDeclarations", "classMemberDeclaration", "anonymousInitializer", + "companionObject", "functionValueParameters", "functionValueParameter", + "functionDeclaration", "functionBody", "variableDeclaration", "multiVariableDeclaration", + "propertyDeclaration", "propertyDelegate", "getter", "setter", "parametersWithOptionalType", + "functionValueParameterWithOptionalType", "parameterWithOptionalType", + "parameter", "objectDeclaration", "secondaryConstructor", "constructorDelegationCall", + "enumClassBody", "enumEntries", "enumEntry", "type", "typeReference", + "nullableType", "quest", "userType", "simpleUserType", "typeProjection", + "typeProjectionModifiers", "typeProjectionModifier", "functionType", + "functionTypeParameters", "parenthesizedType", "receiverType", "parenthesizedUserType", + "definitelyNonNullableType", "statements", "statement", "label", "controlStructureBody", + "block", "loopStatement", "forStatement", "whileStatement", "doWhileStatement", + "assignment", "semi", "semis", "expression", "disjunction", "conjunction", + "equality", "comparison", "genericCallLikeComparison", "infixOperation", + "elvisExpression", "elvis", "infixFunctionCall", "rangeExpression", + "additiveExpression", "multiplicativeExpression", "asExpression", "prefixUnaryExpression", + "unaryPrefix", "postfixUnaryExpression", "postfixUnarySuffix", "directlyAssignableExpression", + "parenthesizedDirectlyAssignableExpression", "assignableExpression", + "parenthesizedAssignableExpression", "assignableSuffix", "indexingSuffix", + "navigationSuffix", "callSuffix", "annotatedLambda", "typeArguments", + "valueArguments", "valueArgument", "primaryExpression", "parenthesizedExpression", + "collectionLiteral", "literalConstant", "stringLiteral", "lineStringLiteral", + "multiLineStringLiteral", "lineStringContent", "lineStringExpression", + "multiLineStringContent", "multiLineStringExpression", "lambdaLiteral", + "lambdaParameters", "lambdaParameter", "anonymousFunction", "functionLiteral", + "objectLiteral", "thisExpression", "superExpression", "ifExpression", + "whenSubject", "whenExpression", "whenEntry", "whenCondition", "rangeTest", + "typeTest", "tryExpression", "catchBlock", "finallyBlock", "jumpExpression", + "callableReference", "assignmentAndOperator", "equalityOperator", "comparisonOperator", + "inOperator", "isOperator", "additiveOperator", "multiplicativeOperator", + "asOperator", "prefixUnaryOperator", "postfixUnaryOperator", "excl", + "memberAccessOperator", "safeNav", "modifiers", "parameterModifiers", + "modifier", "typeModifiers", "typeModifier", "classModifier", "memberModifier", + "visibilityModifier", "varianceModifier", "typeParameterModifiers", + "typeParameterModifier", "functionModifier", "propertyModifier", "inheritanceModifier", + "parameterModifier", "reificationModifier", "platformModifier", "annotation", + "singleAnnotation", "multiAnnotation", "annotationUseSiteTarget", "unescapedAnnotation", + "simpleIdentifier", "identifier", + } + staticData.predictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 172, 3486, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, + 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, + 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, + 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, + 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, + 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, + 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, + 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, + 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, + 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, + 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, + 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, + 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, + 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, + 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, + 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, + 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, + 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, + 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, + 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, + 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, + 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, + 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, + 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, + 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, + 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, + 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, + 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, + 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, + 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, + 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, + 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, + 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, + 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, + 171, 2, 172, 7, 172, 2, 173, 7, 173, 1, 0, 3, 0, 350, 8, 0, 1, 0, 5, 0, + 353, 8, 0, 10, 0, 12, 0, 356, 9, 0, 1, 0, 5, 0, 359, 8, 0, 10, 0, 12, 0, + 362, 9, 0, 1, 0, 1, 0, 1, 0, 5, 0, 367, 8, 0, 10, 0, 12, 0, 370, 9, 0, + 1, 0, 1, 0, 1, 1, 3, 1, 375, 8, 1, 1, 1, 5, 1, 378, 8, 1, 10, 1, 12, 1, + 381, 9, 1, 1, 1, 5, 1, 384, 8, 1, 10, 1, 12, 1, 387, 9, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 5, 1, 394, 8, 1, 10, 1, 12, 1, 397, 9, 1, 1, 1, 1, 1, + 1, 2, 1, 2, 4, 2, 403, 8, 2, 11, 2, 12, 2, 404, 1, 3, 1, 3, 1, 3, 5, 3, + 410, 8, 3, 10, 3, 12, 3, 413, 9, 3, 1, 3, 1, 3, 5, 3, 417, 8, 3, 10, 3, + 12, 3, 420, 9, 3, 1, 3, 1, 3, 4, 3, 424, 8, 3, 11, 3, 12, 3, 425, 1, 3, + 1, 3, 1, 3, 3, 3, 431, 8, 3, 1, 3, 5, 3, 434, 8, 3, 10, 3, 12, 3, 437, + 9, 3, 1, 4, 1, 4, 1, 4, 3, 4, 442, 8, 4, 3, 4, 444, 8, 4, 1, 5, 5, 5, 447, + 8, 5, 10, 5, 12, 5, 450, 9, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 457, + 8, 6, 1, 6, 3, 6, 460, 8, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 467, 8, + 8, 1, 9, 3, 9, 470, 8, 9, 1, 9, 1, 9, 5, 9, 474, 8, 9, 10, 9, 12, 9, 477, + 9, 9, 1, 9, 1, 9, 5, 9, 481, 8, 9, 10, 9, 12, 9, 484, 9, 9, 1, 9, 3, 9, + 487, 8, 9, 1, 9, 5, 9, 490, 8, 9, 10, 9, 12, 9, 493, 9, 9, 1, 9, 1, 9, + 5, 9, 497, 8, 9, 10, 9, 12, 9, 500, 9, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, + 10, 1, 10, 1, 10, 3, 10, 509, 8, 10, 1, 11, 3, 11, 512, 8, 11, 1, 11, 1, + 11, 1, 11, 5, 11, 517, 8, 11, 10, 11, 12, 11, 520, 9, 11, 3, 11, 522, 8, + 11, 1, 11, 3, 11, 525, 8, 11, 1, 11, 5, 11, 528, 8, 11, 10, 11, 12, 11, + 531, 9, 11, 1, 11, 1, 11, 5, 11, 535, 8, 11, 10, 11, 12, 11, 538, 9, 11, + 1, 11, 3, 11, 541, 8, 11, 1, 11, 5, 11, 544, 8, 11, 10, 11, 12, 11, 547, + 9, 11, 1, 11, 3, 11, 550, 8, 11, 1, 11, 5, 11, 553, 8, 11, 10, 11, 12, + 11, 556, 9, 11, 1, 11, 1, 11, 5, 11, 560, 8, 11, 10, 11, 12, 11, 563, 9, + 11, 1, 11, 3, 11, 566, 8, 11, 1, 11, 5, 11, 569, 8, 11, 10, 11, 12, 11, + 572, 9, 11, 1, 11, 3, 11, 575, 8, 11, 1, 11, 5, 11, 578, 8, 11, 10, 11, + 12, 11, 581, 9, 11, 1, 11, 1, 11, 5, 11, 585, 8, 11, 10, 11, 12, 11, 588, + 9, 11, 1, 11, 3, 11, 591, 8, 11, 1, 12, 3, 12, 594, 8, 12, 1, 12, 1, 12, + 5, 12, 598, 8, 12, 10, 12, 12, 12, 601, 9, 12, 3, 12, 603, 8, 12, 1, 12, + 1, 12, 1, 13, 1, 13, 5, 13, 609, 8, 13, 10, 13, 12, 13, 612, 9, 13, 1, + 13, 1, 13, 5, 13, 616, 8, 13, 10, 13, 12, 13, 619, 9, 13, 1, 13, 1, 13, + 1, 14, 1, 14, 5, 14, 625, 8, 14, 10, 14, 12, 14, 628, 9, 14, 1, 14, 1, + 14, 5, 14, 632, 8, 14, 10, 14, 12, 14, 635, 9, 14, 1, 14, 1, 14, 5, 14, + 639, 8, 14, 10, 14, 12, 14, 642, 9, 14, 1, 14, 5, 14, 645, 8, 14, 10, 14, + 12, 14, 648, 9, 14, 1, 14, 5, 14, 651, 8, 14, 10, 14, 12, 14, 654, 9, 14, + 1, 14, 3, 14, 657, 8, 14, 3, 14, 659, 8, 14, 1, 14, 5, 14, 662, 8, 14, + 10, 14, 12, 14, 665, 9, 14, 1, 14, 1, 14, 1, 15, 3, 15, 670, 8, 15, 1, + 15, 3, 15, 673, 8, 15, 1, 15, 5, 15, 676, 8, 15, 10, 15, 12, 15, 679, 9, + 15, 1, 15, 1, 15, 1, 15, 5, 15, 684, 8, 15, 10, 15, 12, 15, 687, 9, 15, + 1, 15, 1, 15, 5, 15, 691, 8, 15, 10, 15, 12, 15, 694, 9, 15, 1, 15, 1, + 15, 5, 15, 698, 8, 15, 10, 15, 12, 15, 701, 9, 15, 1, 15, 3, 15, 704, 8, + 15, 1, 16, 1, 16, 5, 16, 708, 8, 16, 10, 16, 12, 16, 711, 9, 16, 1, 16, + 1, 16, 5, 16, 715, 8, 16, 10, 16, 12, 16, 718, 9, 16, 1, 16, 5, 16, 721, + 8, 16, 10, 16, 12, 16, 724, 9, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 5, 17, 732, 8, 17, 10, 17, 12, 17, 735, 9, 17, 1, 17, 3, 17, 738, 8, + 17, 1, 18, 1, 18, 1, 18, 1, 19, 5, 19, 744, 8, 19, 10, 19, 12, 19, 747, + 9, 19, 1, 19, 5, 19, 750, 8, 19, 10, 19, 12, 19, 753, 9, 19, 1, 19, 1, + 19, 1, 20, 1, 20, 3, 20, 759, 8, 20, 1, 20, 5, 20, 762, 8, 20, 10, 20, + 12, 20, 765, 9, 20, 1, 20, 1, 20, 5, 20, 769, 8, 20, 10, 20, 12, 20, 772, + 9, 20, 1, 20, 1, 20, 1, 21, 1, 21, 5, 21, 778, 8, 21, 10, 21, 12, 21, 781, + 9, 21, 1, 21, 1, 21, 5, 21, 785, 8, 21, 10, 21, 12, 21, 788, 9, 21, 1, + 21, 1, 21, 5, 21, 792, 8, 21, 10, 21, 12, 21, 795, 9, 21, 1, 21, 5, 21, + 798, 8, 21, 10, 21, 12, 21, 801, 9, 21, 1, 21, 5, 21, 804, 8, 21, 10, 21, + 12, 21, 807, 9, 21, 1, 21, 3, 21, 810, 8, 21, 1, 21, 5, 21, 813, 8, 21, + 10, 21, 12, 21, 816, 9, 21, 1, 21, 1, 21, 1, 22, 3, 22, 821, 8, 22, 1, + 22, 5, 22, 824, 8, 22, 10, 22, 12, 22, 827, 9, 22, 1, 22, 1, 22, 5, 22, + 831, 8, 22, 10, 22, 12, 22, 834, 9, 22, 1, 22, 1, 22, 5, 22, 838, 8, 22, + 10, 22, 12, 22, 841, 9, 22, 1, 22, 3, 22, 844, 8, 22, 1, 23, 1, 23, 5, + 23, 848, 8, 23, 10, 23, 12, 23, 851, 9, 23, 1, 23, 1, 23, 5, 23, 855, 8, + 23, 10, 23, 12, 23, 858, 9, 23, 1, 23, 1, 23, 5, 23, 862, 8, 23, 10, 23, + 12, 23, 865, 9, 23, 1, 23, 5, 23, 868, 8, 23, 10, 23, 12, 23, 871, 9, 23, + 1, 24, 5, 24, 874, 8, 24, 10, 24, 12, 24, 877, 9, 24, 1, 24, 1, 24, 5, + 24, 881, 8, 24, 10, 24, 12, 24, 884, 9, 24, 1, 24, 1, 24, 5, 24, 888, 8, + 24, 10, 24, 12, 24, 891, 9, 24, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 897, + 8, 25, 5, 25, 899, 8, 25, 10, 25, 12, 25, 902, 9, 25, 1, 26, 1, 26, 1, + 26, 1, 26, 3, 26, 908, 8, 26, 1, 27, 1, 27, 5, 27, 912, 8, 27, 10, 27, + 12, 27, 915, 9, 27, 1, 27, 1, 27, 1, 28, 3, 28, 920, 8, 28, 1, 28, 1, 28, + 5, 28, 924, 8, 28, 10, 28, 12, 28, 927, 9, 28, 1, 28, 1, 28, 5, 28, 931, + 8, 28, 10, 28, 12, 28, 934, 9, 28, 1, 28, 3, 28, 937, 8, 28, 1, 28, 5, + 28, 940, 8, 28, 10, 28, 12, 28, 943, 9, 28, 1, 28, 1, 28, 5, 28, 947, 8, + 28, 10, 28, 12, 28, 950, 9, 28, 1, 28, 3, 28, 953, 8, 28, 1, 28, 5, 28, + 956, 8, 28, 10, 28, 12, 28, 959, 9, 28, 1, 28, 3, 28, 962, 8, 28, 1, 29, + 1, 29, 5, 29, 966, 8, 29, 10, 29, 12, 29, 969, 9, 29, 1, 29, 1, 29, 5, + 29, 973, 8, 29, 10, 29, 12, 29, 976, 9, 29, 1, 29, 1, 29, 5, 29, 980, 8, + 29, 10, 29, 12, 29, 983, 9, 29, 1, 29, 5, 29, 986, 8, 29, 10, 29, 12, 29, + 989, 9, 29, 1, 29, 5, 29, 992, 8, 29, 10, 29, 12, 29, 995, 9, 29, 1, 29, + 3, 29, 998, 8, 29, 3, 29, 1000, 8, 29, 1, 29, 5, 29, 1003, 8, 29, 10, 29, + 12, 29, 1006, 9, 29, 1, 29, 1, 29, 1, 30, 3, 30, 1011, 8, 30, 1, 30, 1, + 30, 5, 30, 1015, 8, 30, 10, 30, 12, 30, 1018, 9, 30, 1, 30, 1, 30, 5, 30, + 1022, 8, 30, 10, 30, 12, 30, 1025, 9, 30, 1, 30, 3, 30, 1028, 8, 30, 1, + 31, 3, 31, 1031, 8, 31, 1, 31, 1, 31, 5, 31, 1035, 8, 31, 10, 31, 12, 31, + 1038, 9, 31, 1, 31, 3, 31, 1041, 8, 31, 1, 31, 5, 31, 1044, 8, 31, 10, + 31, 12, 31, 1047, 9, 31, 1, 31, 1, 31, 5, 31, 1051, 8, 31, 10, 31, 12, + 31, 1054, 9, 31, 1, 31, 1, 31, 3, 31, 1058, 8, 31, 1, 31, 5, 31, 1061, + 8, 31, 10, 31, 12, 31, 1064, 9, 31, 1, 31, 1, 31, 5, 31, 1068, 8, 31, 10, + 31, 12, 31, 1071, 9, 31, 1, 31, 1, 31, 5, 31, 1075, 8, 31, 10, 31, 12, + 31, 1078, 9, 31, 1, 31, 1, 31, 5, 31, 1082, 8, 31, 10, 31, 12, 31, 1085, + 9, 31, 1, 31, 3, 31, 1088, 8, 31, 1, 31, 5, 31, 1091, 8, 31, 10, 31, 12, + 31, 1094, 9, 31, 1, 31, 3, 31, 1097, 8, 31, 1, 31, 5, 31, 1100, 8, 31, + 10, 31, 12, 31, 1103, 9, 31, 1, 31, 3, 31, 1106, 8, 31, 1, 32, 1, 32, 1, + 32, 5, 32, 1111, 8, 32, 10, 32, 12, 32, 1114, 9, 32, 1, 32, 3, 32, 1117, + 8, 32, 1, 33, 5, 33, 1120, 8, 33, 10, 33, 12, 33, 1123, 9, 33, 1, 33, 5, + 33, 1126, 8, 33, 10, 33, 12, 33, 1129, 9, 33, 1, 33, 1, 33, 5, 33, 1133, + 8, 33, 10, 33, 12, 33, 1136, 9, 33, 1, 33, 1, 33, 5, 33, 1140, 8, 33, 10, + 33, 12, 33, 1143, 9, 33, 1, 33, 3, 33, 1146, 8, 33, 1, 34, 1, 34, 5, 34, + 1150, 8, 34, 10, 34, 12, 34, 1153, 9, 34, 1, 34, 1, 34, 5, 34, 1157, 8, + 34, 10, 34, 12, 34, 1160, 9, 34, 1, 34, 1, 34, 5, 34, 1164, 8, 34, 10, + 34, 12, 34, 1167, 9, 34, 1, 34, 5, 34, 1170, 8, 34, 10, 34, 12, 34, 1173, + 9, 34, 1, 34, 5, 34, 1176, 8, 34, 10, 34, 12, 34, 1179, 9, 34, 1, 34, 3, + 34, 1182, 8, 34, 1, 34, 5, 34, 1185, 8, 34, 10, 34, 12, 34, 1188, 9, 34, + 1, 34, 1, 34, 1, 35, 3, 35, 1193, 8, 35, 1, 35, 1, 35, 5, 35, 1197, 8, + 35, 10, 35, 12, 35, 1200, 9, 35, 1, 35, 3, 35, 1203, 8, 35, 1, 35, 5, 35, + 1206, 8, 35, 10, 35, 12, 35, 1209, 9, 35, 1, 35, 1, 35, 5, 35, 1213, 8, + 35, 10, 35, 12, 35, 1216, 9, 35, 1, 35, 1, 35, 3, 35, 1220, 8, 35, 1, 35, + 5, 35, 1223, 8, 35, 10, 35, 12, 35, 1226, 9, 35, 1, 35, 1, 35, 3, 35, 1230, + 8, 35, 1, 35, 5, 35, 1233, 8, 35, 10, 35, 12, 35, 1236, 9, 35, 1, 35, 3, + 35, 1239, 8, 35, 1, 35, 5, 35, 1242, 8, 35, 10, 35, 12, 35, 1245, 9, 35, + 1, 35, 1, 35, 5, 35, 1249, 8, 35, 10, 35, 12, 35, 1252, 9, 35, 1, 35, 1, + 35, 3, 35, 1256, 8, 35, 3, 35, 1258, 8, 35, 1, 35, 4, 35, 1261, 8, 35, + 11, 35, 12, 35, 1262, 1, 35, 3, 35, 1266, 8, 35, 1, 35, 5, 35, 1269, 8, + 35, 10, 35, 12, 35, 1272, 9, 35, 1, 35, 3, 35, 1275, 8, 35, 1, 35, 5, 35, + 1278, 8, 35, 10, 35, 12, 35, 1281, 9, 35, 1, 35, 3, 35, 1284, 8, 35, 1, + 35, 3, 35, 1287, 8, 35, 1, 35, 3, 35, 1290, 8, 35, 1, 35, 5, 35, 1293, + 8, 35, 10, 35, 12, 35, 1296, 9, 35, 1, 35, 3, 35, 1299, 8, 35, 1, 35, 3, + 35, 1302, 8, 35, 3, 35, 1304, 8, 35, 1, 36, 1, 36, 5, 36, 1308, 8, 36, + 10, 36, 12, 36, 1311, 9, 36, 1, 36, 1, 36, 1, 37, 3, 37, 1316, 8, 37, 1, + 37, 1, 37, 5, 37, 1320, 8, 37, 10, 37, 12, 37, 1323, 9, 37, 1, 37, 1, 37, + 5, 37, 1327, 8, 37, 10, 37, 12, 37, 1330, 9, 37, 1, 37, 1, 37, 5, 37, 1334, + 8, 37, 10, 37, 12, 37, 1337, 9, 37, 1, 37, 1, 37, 5, 37, 1341, 8, 37, 10, + 37, 12, 37, 1344, 9, 37, 1, 37, 3, 37, 1347, 8, 37, 1, 37, 5, 37, 1350, + 8, 37, 10, 37, 12, 37, 1353, 9, 37, 1, 37, 3, 37, 1356, 8, 37, 1, 38, 3, + 38, 1359, 8, 38, 1, 38, 1, 38, 5, 38, 1363, 8, 38, 10, 38, 12, 38, 1366, + 9, 38, 1, 38, 1, 38, 5, 38, 1370, 8, 38, 10, 38, 12, 38, 1373, 9, 38, 1, + 38, 1, 38, 5, 38, 1377, 8, 38, 10, 38, 12, 38, 1380, 9, 38, 1, 38, 3, 38, + 1383, 8, 38, 1, 38, 5, 38, 1386, 8, 38, 10, 38, 12, 38, 1389, 9, 38, 1, + 38, 1, 38, 5, 38, 1393, 8, 38, 10, 38, 12, 38, 1396, 9, 38, 1, 38, 1, 38, + 5, 38, 1400, 8, 38, 10, 38, 12, 38, 1403, 9, 38, 1, 38, 3, 38, 1406, 8, + 38, 1, 38, 5, 38, 1409, 8, 38, 10, 38, 12, 38, 1412, 9, 38, 1, 38, 1, 38, + 3, 38, 1416, 8, 38, 1, 39, 1, 39, 5, 39, 1420, 8, 39, 10, 39, 12, 39, 1423, + 9, 39, 1, 39, 1, 39, 5, 39, 1427, 8, 39, 10, 39, 12, 39, 1430, 9, 39, 1, + 39, 1, 39, 5, 39, 1434, 8, 39, 10, 39, 12, 39, 1437, 9, 39, 1, 39, 5, 39, + 1440, 8, 39, 10, 39, 12, 39, 1443, 9, 39, 1, 39, 5, 39, 1446, 8, 39, 10, + 39, 12, 39, 1449, 9, 39, 1, 39, 3, 39, 1452, 8, 39, 3, 39, 1454, 8, 39, + 1, 39, 5, 39, 1457, 8, 39, 10, 39, 12, 39, 1460, 9, 39, 1, 39, 1, 39, 1, + 40, 3, 40, 1465, 8, 40, 1, 40, 1, 40, 5, 40, 1469, 8, 40, 10, 40, 12, 40, + 1472, 9, 40, 1, 40, 1, 40, 5, 40, 1476, 8, 40, 10, 40, 12, 40, 1479, 9, + 40, 1, 40, 3, 40, 1482, 8, 40, 1, 41, 1, 41, 5, 41, 1486, 8, 41, 10, 41, + 12, 41, 1489, 9, 41, 1, 41, 1, 41, 5, 41, 1493, 8, 41, 10, 41, 12, 41, + 1496, 9, 41, 1, 41, 3, 41, 1499, 8, 41, 1, 42, 1, 42, 5, 42, 1503, 8, 42, + 10, 42, 12, 42, 1506, 9, 42, 1, 42, 1, 42, 5, 42, 1510, 8, 42, 10, 42, + 12, 42, 1513, 9, 42, 1, 42, 1, 42, 1, 43, 3, 43, 1518, 8, 43, 1, 43, 1, + 43, 5, 43, 1522, 8, 43, 10, 43, 12, 43, 1525, 9, 43, 1, 43, 1, 43, 5, 43, + 1529, 8, 43, 10, 43, 12, 43, 1532, 9, 43, 1, 43, 1, 43, 5, 43, 1536, 8, + 43, 10, 43, 12, 43, 1539, 9, 43, 1, 43, 3, 43, 1542, 8, 43, 1, 43, 5, 43, + 1545, 8, 43, 10, 43, 12, 43, 1548, 9, 43, 1, 43, 3, 43, 1551, 8, 43, 1, + 44, 3, 44, 1554, 8, 44, 1, 44, 1, 44, 5, 44, 1558, 8, 44, 10, 44, 12, 44, + 1561, 9, 44, 1, 44, 1, 44, 5, 44, 1565, 8, 44, 10, 44, 12, 44, 1568, 9, + 44, 1, 44, 1, 44, 5, 44, 1572, 8, 44, 10, 44, 12, 44, 1575, 9, 44, 1, 44, + 3, 44, 1578, 8, 44, 1, 44, 5, 44, 1581, 8, 44, 10, 44, 12, 44, 1584, 9, + 44, 1, 44, 3, 44, 1587, 8, 44, 1, 45, 1, 45, 5, 45, 1591, 8, 45, 10, 45, + 12, 45, 1594, 9, 45, 1, 45, 1, 45, 1, 46, 1, 46, 5, 46, 1600, 8, 46, 10, + 46, 12, 46, 1603, 9, 46, 1, 46, 3, 46, 1606, 8, 46, 1, 46, 5, 46, 1609, + 8, 46, 10, 46, 12, 46, 1612, 9, 46, 1, 46, 1, 46, 5, 46, 1616, 8, 46, 10, + 46, 12, 46, 1619, 9, 46, 1, 46, 3, 46, 1622, 8, 46, 1, 46, 5, 46, 1625, + 8, 46, 10, 46, 12, 46, 1628, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 5, 47, + 1634, 8, 47, 10, 47, 12, 47, 1637, 9, 47, 1, 47, 1, 47, 5, 47, 1641, 8, + 47, 10, 47, 12, 47, 1644, 9, 47, 1, 47, 5, 47, 1647, 8, 47, 10, 47, 12, + 47, 1650, 9, 47, 1, 47, 5, 47, 1653, 8, 47, 10, 47, 12, 47, 1656, 9, 47, + 1, 47, 3, 47, 1659, 8, 47, 1, 48, 1, 48, 5, 48, 1663, 8, 48, 10, 48, 12, + 48, 1666, 9, 48, 3, 48, 1668, 8, 48, 1, 48, 1, 48, 5, 48, 1672, 8, 48, + 10, 48, 12, 48, 1675, 9, 48, 1, 48, 3, 48, 1678, 8, 48, 1, 48, 5, 48, 1681, + 8, 48, 10, 48, 12, 48, 1684, 9, 48, 1, 48, 3, 48, 1687, 8, 48, 1, 49, 3, + 49, 1690, 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1697, 8, 49, + 1, 50, 1, 50, 3, 50, 1701, 8, 50, 1, 51, 1, 51, 3, 51, 1705, 8, 51, 1, + 51, 5, 51, 1708, 8, 51, 10, 51, 12, 51, 1711, 9, 51, 1, 51, 4, 51, 1714, + 8, 51, 11, 51, 12, 51, 1715, 1, 52, 1, 52, 1, 53, 1, 53, 5, 53, 1722, 8, + 53, 10, 53, 12, 53, 1725, 9, 53, 1, 53, 1, 53, 5, 53, 1729, 8, 53, 10, + 53, 12, 53, 1732, 9, 53, 1, 53, 5, 53, 1735, 8, 53, 10, 53, 12, 53, 1738, + 9, 53, 1, 54, 1, 54, 5, 54, 1742, 8, 54, 10, 54, 12, 54, 1745, 9, 54, 1, + 54, 3, 54, 1748, 8, 54, 1, 55, 3, 55, 1751, 8, 55, 1, 55, 1, 55, 3, 55, + 1755, 8, 55, 1, 56, 4, 56, 1758, 8, 56, 11, 56, 12, 56, 1759, 1, 57, 1, + 57, 5, 57, 1764, 8, 57, 10, 57, 12, 57, 1767, 9, 57, 1, 57, 3, 57, 1770, + 8, 57, 1, 58, 1, 58, 5, 58, 1774, 8, 58, 10, 58, 12, 58, 1777, 9, 58, 1, + 58, 1, 58, 5, 58, 1781, 8, 58, 10, 58, 12, 58, 1784, 9, 58, 3, 58, 1786, + 8, 58, 1, 58, 1, 58, 5, 58, 1790, 8, 58, 10, 58, 12, 58, 1793, 9, 58, 1, + 58, 1, 58, 5, 58, 1797, 8, 58, 10, 58, 12, 58, 1800, 9, 58, 1, 58, 1, 58, + 1, 59, 1, 59, 5, 59, 1806, 8, 59, 10, 59, 12, 59, 1809, 9, 59, 1, 59, 1, + 59, 3, 59, 1813, 8, 59, 1, 59, 5, 59, 1816, 8, 59, 10, 59, 12, 59, 1819, + 9, 59, 1, 59, 1, 59, 5, 59, 1823, 8, 59, 10, 59, 12, 59, 1826, 9, 59, 1, + 59, 1, 59, 3, 59, 1830, 8, 59, 5, 59, 1832, 8, 59, 10, 59, 12, 59, 1835, + 9, 59, 1, 59, 5, 59, 1838, 8, 59, 10, 59, 12, 59, 1841, 9, 59, 1, 59, 3, + 59, 1844, 8, 59, 1, 59, 5, 59, 1847, 8, 59, 10, 59, 12, 59, 1850, 9, 59, + 1, 59, 1, 59, 1, 60, 1, 60, 5, 60, 1856, 8, 60, 10, 60, 12, 60, 1859, 9, + 60, 1, 60, 1, 60, 5, 60, 1863, 8, 60, 10, 60, 12, 60, 1866, 9, 60, 1, 60, + 1, 60, 1, 61, 3, 61, 1871, 8, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1876, 8, + 61, 1, 62, 1, 62, 5, 62, 1880, 8, 62, 10, 62, 12, 62, 1883, 9, 62, 1, 62, + 1, 62, 3, 62, 1887, 8, 62, 1, 62, 5, 62, 1890, 8, 62, 10, 62, 12, 62, 1893, + 9, 62, 1, 62, 1, 62, 1, 63, 3, 63, 1898, 8, 63, 1, 63, 1, 63, 3, 63, 1902, + 8, 63, 1, 63, 5, 63, 1905, 8, 63, 10, 63, 12, 63, 1908, 9, 63, 1, 63, 1, + 63, 5, 63, 1912, 8, 63, 10, 63, 12, 63, 1915, 9, 63, 1, 63, 3, 63, 1918, + 8, 63, 1, 63, 1, 63, 3, 63, 1922, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 5, + 64, 1928, 8, 64, 10, 64, 12, 64, 1931, 9, 64, 3, 64, 1933, 8, 64, 1, 64, + 3, 64, 1936, 8, 64, 1, 65, 1, 65, 5, 65, 1940, 8, 65, 10, 65, 12, 65, 1943, + 9, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1949, 8, 65, 1, 66, 1, 66, 1, + 66, 5, 66, 1954, 8, 66, 10, 66, 12, 66, 1957, 9, 66, 1, 67, 1, 67, 3, 67, + 1961, 8, 67, 1, 68, 1, 68, 5, 68, 1965, 8, 68, 10, 68, 12, 68, 1968, 9, + 68, 1, 68, 1, 68, 5, 68, 1972, 8, 68, 10, 68, 12, 68, 1975, 9, 68, 1, 68, + 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1982, 8, 69, 1, 70, 1, 70, 5, 70, 1986, + 8, 70, 10, 70, 12, 70, 1989, 9, 70, 1, 70, 1, 70, 5, 70, 1993, 8, 70, 10, + 70, 12, 70, 1996, 9, 70, 1, 70, 1, 70, 3, 70, 2000, 8, 70, 1, 70, 1, 70, + 1, 70, 1, 70, 5, 70, 2006, 8, 70, 10, 70, 12, 70, 2009, 9, 70, 1, 70, 3, + 70, 2012, 8, 70, 1, 71, 1, 71, 5, 71, 2016, 8, 71, 10, 71, 12, 71, 2019, + 9, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2025, 8, 71, 10, 71, 12, 71, + 2028, 9, 71, 1, 71, 1, 71, 3, 71, 2032, 8, 71, 1, 72, 1, 72, 5, 72, 2036, + 8, 72, 10, 72, 12, 72, 2039, 9, 72, 1, 72, 3, 72, 2042, 8, 72, 1, 72, 5, + 72, 2045, 8, 72, 10, 72, 12, 72, 2048, 9, 72, 1, 72, 1, 72, 5, 72, 2052, + 8, 72, 10, 72, 12, 72, 2055, 9, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, + 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2067, 8, 73, 1, 73, 5, 73, 2070, + 8, 73, 10, 73, 12, 73, 2073, 9, 73, 1, 73, 1, 73, 1, 74, 1, 74, 5, 74, + 2079, 8, 74, 10, 74, 12, 74, 2082, 9, 74, 1, 75, 4, 75, 2085, 8, 75, 11, + 75, 12, 75, 2086, 1, 76, 1, 76, 1, 77, 1, 77, 5, 77, 2093, 8, 77, 10, 77, + 12, 77, 2096, 9, 77, 1, 77, 1, 77, 5, 77, 2100, 8, 77, 10, 77, 12, 77, + 2103, 9, 77, 1, 77, 5, 77, 2106, 8, 77, 10, 77, 12, 77, 2109, 9, 77, 1, + 78, 1, 78, 5, 78, 2113, 8, 78, 10, 78, 12, 78, 2116, 9, 78, 1, 78, 1, 78, + 5, 78, 2120, 8, 78, 10, 78, 12, 78, 2123, 9, 78, 1, 78, 5, 78, 2126, 8, + 78, 10, 78, 12, 78, 2129, 9, 78, 1, 79, 1, 79, 1, 79, 5, 79, 2134, 8, 79, + 10, 79, 12, 79, 2137, 9, 79, 1, 79, 1, 79, 5, 79, 2141, 8, 79, 10, 79, + 12, 79, 2144, 9, 79, 1, 80, 1, 80, 1, 80, 5, 80, 2149, 8, 80, 10, 80, 12, + 80, 2152, 9, 80, 1, 80, 1, 80, 5, 80, 2156, 8, 80, 10, 80, 12, 80, 2159, + 9, 80, 1, 81, 1, 81, 5, 81, 2163, 8, 81, 10, 81, 12, 81, 2166, 9, 81, 1, + 82, 1, 82, 1, 82, 5, 82, 2171, 8, 82, 10, 82, 12, 82, 2174, 9, 82, 1, 82, + 1, 82, 1, 82, 1, 82, 5, 82, 2180, 8, 82, 10, 82, 12, 82, 2183, 9, 82, 1, + 82, 1, 82, 5, 82, 2187, 8, 82, 10, 82, 12, 82, 2190, 9, 82, 1, 83, 1, 83, + 5, 83, 2194, 8, 83, 10, 83, 12, 83, 2197, 9, 83, 1, 83, 1, 83, 5, 83, 2201, + 8, 83, 10, 83, 12, 83, 2204, 9, 83, 1, 83, 1, 83, 5, 83, 2208, 8, 83, 10, + 83, 12, 83, 2211, 9, 83, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 5, 85, + 2219, 8, 85, 10, 85, 12, 85, 2222, 9, 85, 1, 85, 1, 85, 5, 85, 2226, 8, + 85, 10, 85, 12, 85, 2229, 9, 85, 1, 86, 1, 86, 1, 86, 5, 86, 2234, 8, 86, + 10, 86, 12, 86, 2237, 9, 86, 1, 86, 5, 86, 2240, 8, 86, 10, 86, 12, 86, + 2243, 9, 86, 1, 87, 1, 87, 1, 87, 5, 87, 2248, 8, 87, 10, 87, 12, 87, 2251, + 9, 87, 1, 87, 1, 87, 5, 87, 2255, 8, 87, 10, 87, 12, 87, 2258, 9, 87, 1, + 88, 1, 88, 1, 88, 5, 88, 2263, 8, 88, 10, 88, 12, 88, 2266, 9, 88, 1, 88, + 1, 88, 5, 88, 2270, 8, 88, 10, 88, 12, 88, 2273, 9, 88, 1, 89, 1, 89, 5, + 89, 2277, 8, 89, 10, 89, 12, 89, 2280, 9, 89, 1, 89, 1, 89, 5, 89, 2284, + 8, 89, 10, 89, 12, 89, 2287, 9, 89, 1, 89, 1, 89, 5, 89, 2291, 8, 89, 10, + 89, 12, 89, 2294, 9, 89, 1, 90, 5, 90, 2297, 8, 90, 10, 90, 12, 90, 2300, + 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2308, 8, 91, 10, + 91, 12, 91, 2311, 9, 91, 3, 91, 2313, 8, 91, 1, 92, 1, 92, 5, 92, 2317, + 8, 92, 10, 92, 12, 92, 2320, 9, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, + 3, 93, 2327, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2334, 8, + 94, 1, 95, 1, 95, 5, 95, 2338, 8, 95, 10, 95, 12, 95, 2341, 9, 95, 1, 95, + 1, 95, 5, 95, 2345, 8, 95, 10, 95, 12, 95, 2348, 9, 95, 1, 95, 1, 95, 1, + 96, 1, 96, 3, 96, 2354, 8, 96, 1, 97, 1, 97, 5, 97, 2358, 8, 97, 10, 97, + 12, 97, 2361, 9, 97, 1, 97, 1, 97, 5, 97, 2365, 8, 97, 10, 97, 12, 97, + 2368, 9, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 3, 98, 2375, 8, 98, 1, + 99, 1, 99, 5, 99, 2379, 8, 99, 10, 99, 12, 99, 2382, 9, 99, 1, 99, 1, 99, + 5, 99, 2386, 8, 99, 10, 99, 12, 99, 2389, 9, 99, 1, 99, 1, 99, 5, 99, 2393, + 8, 99, 10, 99, 12, 99, 2396, 9, 99, 1, 99, 5, 99, 2399, 8, 99, 10, 99, + 12, 99, 2402, 9, 99, 1, 99, 5, 99, 2405, 8, 99, 10, 99, 12, 99, 2408, 9, + 99, 1, 99, 3, 99, 2411, 8, 99, 1, 99, 5, 99, 2414, 8, 99, 10, 99, 12, 99, + 2417, 9, 99, 1, 99, 1, 99, 1, 100, 1, 100, 5, 100, 2423, 8, 100, 10, 100, + 12, 100, 2426, 9, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2431, 8, 100, 1, + 101, 3, 101, 2434, 8, 101, 1, 101, 3, 101, 2437, 8, 101, 1, 101, 1, 101, + 3, 101, 2441, 8, 101, 1, 102, 5, 102, 2444, 8, 102, 10, 102, 12, 102, 2447, + 9, 102, 1, 102, 3, 102, 2450, 8, 102, 1, 102, 5, 102, 2453, 8, 102, 10, + 102, 12, 102, 2456, 9, 102, 1, 102, 1, 102, 1, 103, 1, 103, 5, 103, 2462, + 8, 103, 10, 103, 12, 103, 2465, 9, 103, 1, 103, 1, 103, 5, 103, 2469, 8, + 103, 10, 103, 12, 103, 2472, 9, 103, 1, 103, 1, 103, 5, 103, 2476, 8, 103, + 10, 103, 12, 103, 2479, 9, 103, 1, 103, 5, 103, 2482, 8, 103, 10, 103, + 12, 103, 2485, 9, 103, 1, 103, 5, 103, 2488, 8, 103, 10, 103, 12, 103, + 2491, 9, 103, 1, 103, 3, 103, 2494, 8, 103, 1, 103, 5, 103, 2497, 8, 103, + 10, 103, 12, 103, 2500, 9, 103, 1, 103, 1, 103, 1, 104, 1, 104, 5, 104, + 2506, 8, 104, 10, 104, 12, 104, 2509, 9, 104, 1, 104, 1, 104, 5, 104, 2513, + 8, 104, 10, 104, 12, 104, 2516, 9, 104, 1, 104, 1, 104, 5, 104, 2520, 8, + 104, 10, 104, 12, 104, 2523, 9, 104, 1, 104, 5, 104, 2526, 8, 104, 10, + 104, 12, 104, 2529, 9, 104, 1, 104, 5, 104, 2532, 8, 104, 10, 104, 12, + 104, 2535, 9, 104, 1, 104, 3, 104, 2538, 8, 104, 1, 104, 5, 104, 2541, + 8, 104, 10, 104, 12, 104, 2544, 9, 104, 3, 104, 2546, 8, 104, 1, 104, 1, + 104, 1, 105, 3, 105, 2551, 8, 105, 1, 105, 5, 105, 2554, 8, 105, 10, 105, + 12, 105, 2557, 9, 105, 1, 105, 1, 105, 5, 105, 2561, 8, 105, 10, 105, 12, + 105, 2564, 9, 105, 1, 105, 1, 105, 5, 105, 2568, 8, 105, 10, 105, 12, 105, + 2571, 9, 105, 3, 105, 2573, 8, 105, 1, 105, 3, 105, 2576, 8, 105, 1, 105, + 5, 105, 2579, 8, 105, 10, 105, 12, 105, 2582, 9, 105, 1, 105, 1, 105, 1, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2600, 8, 106, 1, 107, 1, 107, + 5, 107, 2604, 8, 107, 10, 107, 12, 107, 2607, 9, 107, 1, 107, 1, 107, 5, + 107, 2611, 8, 107, 10, 107, 12, 107, 2614, 9, 107, 1, 107, 1, 107, 1, 108, + 1, 108, 5, 108, 2620, 8, 108, 10, 108, 12, 108, 2623, 9, 108, 1, 108, 1, + 108, 5, 108, 2627, 8, 108, 10, 108, 12, 108, 2630, 9, 108, 1, 108, 1, 108, + 5, 108, 2634, 8, 108, 10, 108, 12, 108, 2637, 9, 108, 1, 108, 5, 108, 2640, + 8, 108, 10, 108, 12, 108, 2643, 9, 108, 1, 108, 5, 108, 2646, 8, 108, 10, + 108, 12, 108, 2649, 9, 108, 1, 108, 3, 108, 2652, 8, 108, 1, 108, 5, 108, + 2655, 8, 108, 10, 108, 12, 108, 2658, 9, 108, 3, 108, 2660, 8, 108, 1, + 108, 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 3, 110, 2668, 8, 110, 1, 111, + 1, 111, 1, 111, 5, 111, 2673, 8, 111, 10, 111, 12, 111, 2676, 9, 111, 1, + 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 2684, 8, 112, 10, + 112, 12, 112, 2687, 9, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 114, 1, + 114, 5, 114, 2695, 8, 114, 10, 114, 12, 114, 2698, 9, 114, 1, 114, 1, 114, + 5, 114, 2702, 8, 114, 10, 114, 12, 114, 2705, 9, 114, 1, 114, 1, 114, 1, + 115, 1, 115, 1, 116, 1, 116, 5, 116, 2713, 8, 116, 10, 116, 12, 116, 2716, + 9, 116, 1, 116, 1, 116, 5, 116, 2720, 8, 116, 10, 116, 12, 116, 2723, 9, + 116, 1, 116, 1, 116, 1, 117, 1, 117, 5, 117, 2729, 8, 117, 10, 117, 12, + 117, 2732, 9, 117, 1, 117, 3, 117, 2735, 8, 117, 1, 117, 5, 117, 2738, + 8, 117, 10, 117, 12, 117, 2741, 9, 117, 1, 117, 1, 117, 5, 117, 2745, 8, + 117, 10, 117, 12, 117, 2748, 9, 117, 3, 117, 2750, 8, 117, 1, 117, 1, 117, + 5, 117, 2754, 8, 117, 10, 117, 12, 117, 2757, 9, 117, 1, 117, 1, 117, 1, + 118, 1, 118, 5, 118, 2763, 8, 118, 10, 118, 12, 118, 2766, 9, 118, 1, 118, + 1, 118, 5, 118, 2770, 8, 118, 10, 118, 12, 118, 2773, 9, 118, 1, 118, 5, + 118, 2776, 8, 118, 10, 118, 12, 118, 2779, 9, 118, 1, 118, 5, 118, 2782, + 8, 118, 10, 118, 12, 118, 2785, 9, 118, 1, 118, 3, 118, 2788, 8, 118, 1, + 119, 1, 119, 1, 119, 5, 119, 2793, 8, 119, 10, 119, 12, 119, 2796, 9, 119, + 1, 119, 1, 119, 5, 119, 2800, 8, 119, 10, 119, 12, 119, 2803, 9, 119, 1, + 119, 3, 119, 2806, 8, 119, 3, 119, 2808, 8, 119, 1, 120, 1, 120, 5, 120, + 2812, 8, 120, 10, 120, 12, 120, 2815, 9, 120, 1, 120, 1, 120, 5, 120, 2819, + 8, 120, 10, 120, 12, 120, 2822, 9, 120, 1, 120, 1, 120, 3, 120, 2826, 8, + 120, 1, 120, 5, 120, 2829, 8, 120, 10, 120, 12, 120, 2832, 9, 120, 1, 120, + 1, 120, 5, 120, 2836, 8, 120, 10, 120, 12, 120, 2839, 9, 120, 1, 120, 1, + 120, 5, 120, 2843, 8, 120, 10, 120, 12, 120, 2846, 9, 120, 1, 120, 3, 120, + 2849, 8, 120, 1, 120, 5, 120, 2852, 8, 120, 10, 120, 12, 120, 2855, 9, + 120, 1, 120, 3, 120, 2858, 8, 120, 1, 120, 5, 120, 2861, 8, 120, 10, 120, + 12, 120, 2864, 9, 120, 1, 120, 3, 120, 2867, 8, 120, 1, 121, 1, 121, 3, + 121, 2871, 8, 121, 1, 122, 1, 122, 5, 122, 2875, 8, 122, 10, 122, 12, 122, + 2878, 9, 122, 1, 122, 1, 122, 5, 122, 2882, 8, 122, 10, 122, 12, 122, 2885, + 9, 122, 1, 122, 1, 122, 5, 122, 2889, 8, 122, 10, 122, 12, 122, 2892, 9, + 122, 3, 122, 2894, 8, 122, 1, 122, 5, 122, 2897, 8, 122, 10, 122, 12, 122, + 2900, 9, 122, 1, 122, 3, 122, 2903, 8, 122, 1, 123, 1, 123, 1, 124, 1, + 124, 1, 124, 5, 124, 2910, 8, 124, 10, 124, 12, 124, 2913, 9, 124, 1, 124, + 1, 124, 5, 124, 2917, 8, 124, 10, 124, 12, 124, 2920, 9, 124, 1, 124, 1, + 124, 3, 124, 2924, 8, 124, 1, 124, 1, 124, 3, 124, 2928, 8, 124, 1, 124, + 3, 124, 2931, 8, 124, 1, 125, 1, 125, 5, 125, 2935, 8, 125, 10, 125, 12, + 125, 2938, 9, 125, 1, 125, 1, 125, 5, 125, 2942, 8, 125, 10, 125, 12, 125, + 2945, 9, 125, 1, 125, 1, 125, 5, 125, 2949, 8, 125, 10, 125, 12, 125, 2952, + 9, 125, 1, 125, 1, 125, 5, 125, 2956, 8, 125, 10, 125, 12, 125, 2959, 9, + 125, 1, 125, 1, 125, 3, 125, 2963, 8, 125, 1, 125, 5, 125, 2966, 8, 125, + 10, 125, 12, 125, 2969, 9, 125, 1, 125, 3, 125, 2972, 8, 125, 1, 125, 5, + 125, 2975, 8, 125, 10, 125, 12, 125, 2978, 9, 125, 1, 125, 1, 125, 5, 125, + 2982, 8, 125, 10, 125, 12, 125, 2985, 9, 125, 1, 125, 1, 125, 3, 125, 2989, + 8, 125, 1, 125, 3, 125, 2992, 8, 125, 1, 126, 1, 126, 5, 126, 2996, 8, + 126, 10, 126, 12, 126, 2999, 9, 126, 1, 126, 5, 126, 3002, 8, 126, 10, + 126, 12, 126, 3005, 9, 126, 1, 126, 1, 126, 5, 126, 3009, 8, 126, 10, 126, + 12, 126, 3012, 9, 126, 1, 126, 1, 126, 5, 126, 3016, 8, 126, 10, 126, 12, + 126, 3019, 9, 126, 1, 126, 1, 126, 5, 126, 3023, 8, 126, 10, 126, 12, 126, + 3026, 9, 126, 3, 126, 3028, 8, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, + 127, 5, 127, 3035, 8, 127, 10, 127, 12, 127, 3038, 9, 127, 1, 127, 3, 127, + 3041, 8, 127, 1, 127, 5, 127, 3044, 8, 127, 10, 127, 12, 127, 3047, 9, + 127, 1, 127, 1, 127, 5, 127, 3051, 8, 127, 10, 127, 12, 127, 3054, 9, 127, + 1, 127, 1, 127, 5, 127, 3058, 8, 127, 10, 127, 12, 127, 3061, 9, 127, 5, + 127, 3063, 8, 127, 10, 127, 12, 127, 3066, 9, 127, 1, 127, 5, 127, 3069, + 8, 127, 10, 127, 12, 127, 3072, 9, 127, 1, 127, 1, 127, 1, 128, 1, 128, + 5, 128, 3078, 8, 128, 10, 128, 12, 128, 3081, 9, 128, 1, 128, 1, 128, 5, + 128, 3085, 8, 128, 10, 128, 12, 128, 3088, 9, 128, 1, 128, 5, 128, 3091, + 8, 128, 10, 128, 12, 128, 3094, 9, 128, 1, 128, 5, 128, 3097, 8, 128, 10, + 128, 12, 128, 3100, 9, 128, 1, 128, 3, 128, 3103, 8, 128, 1, 128, 5, 128, + 3106, 8, 128, 10, 128, 12, 128, 3109, 9, 128, 1, 128, 1, 128, 5, 128, 3113, + 8, 128, 10, 128, 12, 128, 3116, 9, 128, 1, 128, 1, 128, 3, 128, 3120, 8, + 128, 1, 128, 1, 128, 5, 128, 3124, 8, 128, 10, 128, 12, 128, 3127, 9, 128, + 1, 128, 1, 128, 5, 128, 3131, 8, 128, 10, 128, 12, 128, 3134, 9, 128, 1, + 128, 1, 128, 3, 128, 3138, 8, 128, 3, 128, 3140, 8, 128, 1, 129, 1, 129, + 1, 129, 3, 129, 3145, 8, 129, 1, 130, 1, 130, 5, 130, 3149, 8, 130, 10, + 130, 12, 130, 3152, 9, 130, 1, 130, 1, 130, 1, 131, 1, 131, 5, 131, 3158, + 8, 131, 10, 131, 12, 131, 3161, 9, 131, 1, 131, 1, 131, 1, 132, 1, 132, + 5, 132, 3167, 8, 132, 10, 132, 12, 132, 3170, 9, 132, 1, 132, 1, 132, 5, + 132, 3174, 8, 132, 10, 132, 12, 132, 3177, 9, 132, 1, 132, 4, 132, 3180, + 8, 132, 11, 132, 12, 132, 3181, 1, 132, 5, 132, 3185, 8, 132, 10, 132, + 12, 132, 3188, 9, 132, 1, 132, 3, 132, 3191, 8, 132, 1, 132, 5, 132, 3194, + 8, 132, 10, 132, 12, 132, 3197, 9, 132, 1, 132, 3, 132, 3200, 8, 132, 1, + 133, 1, 133, 5, 133, 3204, 8, 133, 10, 133, 12, 133, 3207, 9, 133, 1, 133, + 1, 133, 5, 133, 3211, 8, 133, 10, 133, 12, 133, 3214, 9, 133, 1, 133, 1, + 133, 1, 133, 1, 133, 5, 133, 3220, 8, 133, 10, 133, 12, 133, 3223, 9, 133, + 1, 133, 3, 133, 3226, 8, 133, 1, 133, 1, 133, 5, 133, 3230, 8, 133, 10, + 133, 12, 133, 3233, 9, 133, 1, 133, 1, 133, 1, 134, 1, 134, 5, 134, 3239, + 8, 134, 10, 134, 12, 134, 3242, 9, 134, 1, 134, 1, 134, 1, 135, 1, 135, + 5, 135, 3248, 8, 135, 10, 135, 12, 135, 3251, 9, 135, 1, 135, 1, 135, 1, + 135, 3, 135, 3256, 8, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3262, + 8, 135, 1, 136, 3, 136, 3265, 8, 136, 1, 136, 1, 136, 5, 136, 3269, 8, + 136, 10, 136, 12, 136, 3272, 9, 136, 1, 136, 1, 136, 3, 136, 3276, 8, 136, + 1, 137, 1, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, + 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 1, 145, 1, 145, + 1, 145, 1, 145, 1, 145, 3, 145, 3299, 8, 145, 1, 146, 1, 146, 1, 146, 1, + 146, 3, 146, 3305, 8, 146, 1, 147, 1, 147, 1, 148, 5, 148, 3310, 8, 148, + 10, 148, 12, 148, 3313, 9, 148, 1, 148, 1, 148, 5, 148, 3317, 8, 148, 10, + 148, 12, 148, 3320, 9, 148, 1, 148, 1, 148, 3, 148, 3324, 8, 148, 1, 149, + 1, 149, 1, 149, 1, 150, 1, 150, 4, 150, 3331, 8, 150, 11, 150, 12, 150, + 3332, 1, 151, 1, 151, 4, 151, 3337, 8, 151, 11, 151, 12, 151, 3338, 1, + 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3349, + 8, 152, 1, 152, 5, 152, 3352, 8, 152, 10, 152, 12, 152, 3355, 9, 152, 1, + 153, 4, 153, 3358, 8, 153, 11, 153, 12, 153, 3359, 1, 154, 1, 154, 1, 154, + 5, 154, 3365, 8, 154, 10, 154, 12, 154, 3368, 9, 154, 3, 154, 3370, 8, + 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, + 159, 4, 159, 3381, 8, 159, 11, 159, 12, 159, 3382, 1, 160, 1, 160, 5, 160, + 3387, 8, 160, 10, 160, 12, 160, 3390, 9, 160, 1, 160, 1, 160, 5, 160, 3394, + 8, 160, 10, 160, 12, 160, 3397, 9, 160, 1, 160, 3, 160, 3400, 8, 160, 1, + 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 165, 1, + 165, 1, 166, 1, 166, 1, 167, 1, 167, 3, 167, 3416, 8, 167, 1, 167, 5, 167, + 3419, 8, 167, 10, 167, 12, 167, 3422, 9, 167, 1, 168, 1, 168, 5, 168, 3426, + 8, 168, 10, 168, 12, 168, 3429, 9, 168, 1, 168, 1, 168, 3, 168, 3433, 8, + 168, 1, 168, 1, 168, 1, 169, 1, 169, 5, 169, 3439, 8, 169, 10, 169, 12, + 169, 3442, 9, 169, 1, 169, 1, 169, 3, 169, 3446, 8, 169, 1, 169, 1, 169, + 4, 169, 3450, 8, 169, 11, 169, 12, 169, 3451, 1, 169, 1, 169, 1, 170, 1, + 170, 1, 170, 5, 170, 3459, 8, 170, 10, 170, 12, 170, 3462, 9, 170, 1, 170, + 1, 170, 1, 171, 1, 171, 3, 171, 3468, 8, 171, 1, 172, 1, 172, 1, 173, 1, + 173, 5, 173, 3474, 8, 173, 10, 173, 12, 173, 3477, 9, 173, 1, 173, 1, 173, + 5, 173, 3481, 8, 173, 10, 173, 12, 173, 3484, 9, 173, 1, 173, 0, 0, 174, + 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, + 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, + 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, + 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, + 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, + 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, + 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, + 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, + 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, + 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, + 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, + 0, 30, 2, 0, 40, 40, 42, 42, 1, 0, 77, 78, 1, 0, 84, 85, 1, 0, 44, 45, + 1, 0, 40, 41, 2, 0, 5, 5, 27, 27, 2, 0, 136, 136, 139, 146, 1, 0, 160, + 162, 1, 0, 165, 167, 2, 0, 60, 60, 84, 84, 2, 0, 57, 57, 98, 98, 1, 0, + 29, 33, 2, 0, 50, 51, 53, 54, 1, 0, 46, 49, 2, 0, 103, 103, 105, 105, 2, + 0, 102, 102, 104, 104, 1, 0, 18, 19, 1, 0, 15, 17, 2, 0, 52, 52, 101, 101, + 1, 0, 24, 25, 1, 0, 112, 117, 2, 0, 124, 124, 129, 129, 1, 0, 108, 111, + 2, 0, 103, 103, 106, 106, 1, 0, 118, 123, 1, 0, 125, 127, 1, 0, 130, 132, + 1, 0, 134, 135, 1, 0, 63, 70, 7, 0, 62, 70, 72, 72, 80, 83, 87, 87, 92, + 93, 106, 135, 147, 147, 3904, 0, 349, 1, 0, 0, 0, 2, 374, 1, 0, 0, 0, 4, + 400, 1, 0, 0, 0, 6, 406, 1, 0, 0, 0, 8, 443, 1, 0, 0, 0, 10, 448, 1, 0, + 0, 0, 12, 451, 1, 0, 0, 0, 14, 461, 1, 0, 0, 0, 16, 464, 1, 0, 0, 0, 18, + 469, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 511, 1, 0, 0, 0, 24, 602, 1, + 0, 0, 0, 26, 606, 1, 0, 0, 0, 28, 622, 1, 0, 0, 0, 30, 669, 1, 0, 0, 0, + 32, 705, 1, 0, 0, 0, 34, 737, 1, 0, 0, 0, 36, 739, 1, 0, 0, 0, 38, 745, + 1, 0, 0, 0, 40, 758, 1, 0, 0, 0, 42, 775, 1, 0, 0, 0, 44, 820, 1, 0, 0, + 0, 46, 845, 1, 0, 0, 0, 48, 875, 1, 0, 0, 0, 50, 900, 1, 0, 0, 0, 52, 907, + 1, 0, 0, 0, 54, 909, 1, 0, 0, 0, 56, 919, 1, 0, 0, 0, 58, 963, 1, 0, 0, + 0, 60, 1010, 1, 0, 0, 0, 62, 1030, 1, 0, 0, 0, 64, 1116, 1, 0, 0, 0, 66, + 1121, 1, 0, 0, 0, 68, 1147, 1, 0, 0, 0, 70, 1192, 1, 0, 0, 0, 72, 1305, + 1, 0, 0, 0, 74, 1315, 1, 0, 0, 0, 76, 1358, 1, 0, 0, 0, 78, 1417, 1, 0, + 0, 0, 80, 1464, 1, 0, 0, 0, 82, 1483, 1, 0, 0, 0, 84, 1500, 1, 0, 0, 0, + 86, 1517, 1, 0, 0, 0, 88, 1553, 1, 0, 0, 0, 90, 1588, 1, 0, 0, 0, 92, 1597, + 1, 0, 0, 0, 94, 1631, 1, 0, 0, 0, 96, 1667, 1, 0, 0, 0, 98, 1689, 1, 0, + 0, 0, 100, 1700, 1, 0, 0, 0, 102, 1704, 1, 0, 0, 0, 104, 1717, 1, 0, 0, + 0, 106, 1719, 1, 0, 0, 0, 108, 1739, 1, 0, 0, 0, 110, 1754, 1, 0, 0, 0, + 112, 1757, 1, 0, 0, 0, 114, 1769, 1, 0, 0, 0, 116, 1785, 1, 0, 0, 0, 118, + 1803, 1, 0, 0, 0, 120, 1853, 1, 0, 0, 0, 122, 1870, 1, 0, 0, 0, 124, 1877, + 1, 0, 0, 0, 126, 1897, 1, 0, 0, 0, 128, 1932, 1, 0, 0, 0, 130, 1941, 1, + 0, 0, 0, 132, 1950, 1, 0, 0, 0, 134, 1960, 1, 0, 0, 0, 136, 1962, 1, 0, + 0, 0, 138, 1981, 1, 0, 0, 0, 140, 1983, 1, 0, 0, 0, 142, 2013, 1, 0, 0, + 0, 144, 2033, 1, 0, 0, 0, 146, 2066, 1, 0, 0, 0, 148, 2076, 1, 0, 0, 0, + 150, 2084, 1, 0, 0, 0, 152, 2088, 1, 0, 0, 0, 154, 2090, 1, 0, 0, 0, 156, + 2110, 1, 0, 0, 0, 158, 2130, 1, 0, 0, 0, 160, 2145, 1, 0, 0, 0, 162, 2160, + 1, 0, 0, 0, 164, 2167, 1, 0, 0, 0, 166, 2191, 1, 0, 0, 0, 168, 2212, 1, + 0, 0, 0, 170, 2215, 1, 0, 0, 0, 172, 2230, 1, 0, 0, 0, 174, 2244, 1, 0, + 0, 0, 176, 2259, 1, 0, 0, 0, 178, 2274, 1, 0, 0, 0, 180, 2298, 1, 0, 0, + 0, 182, 2312, 1, 0, 0, 0, 184, 2314, 1, 0, 0, 0, 186, 2326, 1, 0, 0, 0, + 188, 2333, 1, 0, 0, 0, 190, 2335, 1, 0, 0, 0, 192, 2353, 1, 0, 0, 0, 194, + 2355, 1, 0, 0, 0, 196, 2374, 1, 0, 0, 0, 198, 2376, 1, 0, 0, 0, 200, 2420, + 1, 0, 0, 0, 202, 2433, 1, 0, 0, 0, 204, 2445, 1, 0, 0, 0, 206, 2459, 1, + 0, 0, 0, 208, 2503, 1, 0, 0, 0, 210, 2550, 1, 0, 0, 0, 212, 2599, 1, 0, + 0, 0, 214, 2601, 1, 0, 0, 0, 216, 2617, 1, 0, 0, 0, 218, 2663, 1, 0, 0, + 0, 220, 2667, 1, 0, 0, 0, 222, 2669, 1, 0, 0, 0, 224, 2679, 1, 0, 0, 0, + 226, 2690, 1, 0, 0, 0, 228, 2692, 1, 0, 0, 0, 230, 2708, 1, 0, 0, 0, 232, + 2710, 1, 0, 0, 0, 234, 2726, 1, 0, 0, 0, 236, 2760, 1, 0, 0, 0, 238, 2807, + 1, 0, 0, 0, 240, 2809, 1, 0, 0, 0, 242, 2870, 1, 0, 0, 0, 244, 2872, 1, + 0, 0, 0, 246, 2904, 1, 0, 0, 0, 248, 2930, 1, 0, 0, 0, 250, 2932, 1, 0, + 0, 0, 252, 2993, 1, 0, 0, 0, 254, 3032, 1, 0, 0, 0, 256, 3139, 1, 0, 0, + 0, 258, 3144, 1, 0, 0, 0, 260, 3146, 1, 0, 0, 0, 262, 3155, 1, 0, 0, 0, + 264, 3164, 1, 0, 0, 0, 266, 3201, 1, 0, 0, 0, 268, 3236, 1, 0, 0, 0, 270, + 3261, 1, 0, 0, 0, 272, 3264, 1, 0, 0, 0, 274, 3277, 1, 0, 0, 0, 276, 3279, + 1, 0, 0, 0, 278, 3281, 1, 0, 0, 0, 280, 3283, 1, 0, 0, 0, 282, 3285, 1, + 0, 0, 0, 284, 3287, 1, 0, 0, 0, 286, 3289, 1, 0, 0, 0, 288, 3291, 1, 0, + 0, 0, 290, 3298, 1, 0, 0, 0, 292, 3304, 1, 0, 0, 0, 294, 3306, 1, 0, 0, + 0, 296, 3323, 1, 0, 0, 0, 298, 3325, 1, 0, 0, 0, 300, 3330, 1, 0, 0, 0, + 302, 3336, 1, 0, 0, 0, 304, 3348, 1, 0, 0, 0, 306, 3357, 1, 0, 0, 0, 308, + 3369, 1, 0, 0, 0, 310, 3371, 1, 0, 0, 0, 312, 3373, 1, 0, 0, 0, 314, 3375, + 1, 0, 0, 0, 316, 3377, 1, 0, 0, 0, 318, 3380, 1, 0, 0, 0, 320, 3399, 1, + 0, 0, 0, 322, 3401, 1, 0, 0, 0, 324, 3403, 1, 0, 0, 0, 326, 3405, 1, 0, + 0, 0, 328, 3407, 1, 0, 0, 0, 330, 3409, 1, 0, 0, 0, 332, 3411, 1, 0, 0, + 0, 334, 3415, 1, 0, 0, 0, 336, 3432, 1, 0, 0, 0, 338, 3445, 1, 0, 0, 0, + 340, 3455, 1, 0, 0, 0, 342, 3467, 1, 0, 0, 0, 344, 3469, 1, 0, 0, 0, 346, + 3471, 1, 0, 0, 0, 348, 350, 3, 4, 2, 0, 349, 348, 1, 0, 0, 0, 349, 350, + 1, 0, 0, 0, 350, 354, 1, 0, 0, 0, 351, 353, 5, 5, 0, 0, 352, 351, 1, 0, + 0, 0, 353, 356, 1, 0, 0, 0, 354, 352, 1, 0, 0, 0, 354, 355, 1, 0, 0, 0, + 355, 360, 1, 0, 0, 0, 356, 354, 1, 0, 0, 0, 357, 359, 3, 6, 3, 0, 358, + 357, 1, 0, 0, 0, 359, 362, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 360, 361, + 1, 0, 0, 0, 361, 363, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 363, 364, 3, 8, + 4, 0, 364, 368, 3, 10, 5, 0, 365, 367, 3, 16, 8, 0, 366, 365, 1, 0, 0, + 0, 367, 370, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, + 371, 1, 0, 0, 0, 370, 368, 1, 0, 0, 0, 371, 372, 5, 0, 0, 1, 372, 1, 1, + 0, 0, 0, 373, 375, 3, 4, 2, 0, 374, 373, 1, 0, 0, 0, 374, 375, 1, 0, 0, + 0, 375, 379, 1, 0, 0, 0, 376, 378, 5, 5, 0, 0, 377, 376, 1, 0, 0, 0, 378, + 381, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 385, + 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 382, 384, 3, 6, 3, 0, 383, 382, 1, 0, + 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, + 386, 388, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 389, 3, 8, 4, 0, 389, + 395, 3, 10, 5, 0, 390, 391, 3, 130, 65, 0, 391, 392, 3, 148, 74, 0, 392, + 394, 1, 0, 0, 0, 393, 390, 1, 0, 0, 0, 394, 397, 1, 0, 0, 0, 395, 393, + 1, 0, 0, 0, 395, 396, 1, 0, 0, 0, 396, 398, 1, 0, 0, 0, 397, 395, 1, 0, + 0, 0, 398, 399, 5, 0, 0, 1, 399, 3, 1, 0, 0, 0, 400, 402, 5, 1, 0, 0, 401, + 403, 5, 5, 0, 0, 402, 401, 1, 0, 0, 0, 403, 404, 1, 0, 0, 0, 404, 402, + 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 5, 1, 0, 0, 0, 406, 407, 7, 0, 0, + 0, 407, 411, 5, 62, 0, 0, 408, 410, 5, 5, 0, 0, 409, 408, 1, 0, 0, 0, 410, + 413, 1, 0, 0, 0, 411, 409, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 414, + 1, 0, 0, 0, 413, 411, 1, 0, 0, 0, 414, 418, 5, 26, 0, 0, 415, 417, 5, 5, + 0, 0, 416, 415, 1, 0, 0, 0, 417, 420, 1, 0, 0, 0, 418, 416, 1, 0, 0, 0, + 418, 419, 1, 0, 0, 0, 419, 430, 1, 0, 0, 0, 420, 418, 1, 0, 0, 0, 421, + 423, 5, 11, 0, 0, 422, 424, 3, 342, 171, 0, 423, 422, 1, 0, 0, 0, 424, + 425, 1, 0, 0, 0, 425, 423, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 427, + 1, 0, 0, 0, 427, 428, 5, 12, 0, 0, 428, 431, 1, 0, 0, 0, 429, 431, 3, 342, + 171, 0, 430, 421, 1, 0, 0, 0, 430, 429, 1, 0, 0, 0, 431, 435, 1, 0, 0, + 0, 432, 434, 5, 5, 0, 0, 433, 432, 1, 0, 0, 0, 434, 437, 1, 0, 0, 0, 435, + 433, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 7, 1, 0, 0, 0, 437, 435, 1, + 0, 0, 0, 438, 439, 5, 71, 0, 0, 439, 441, 3, 346, 173, 0, 440, 442, 3, + 148, 74, 0, 441, 440, 1, 0, 0, 0, 441, 442, 1, 0, 0, 0, 442, 444, 1, 0, + 0, 0, 443, 438, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 9, 1, 0, 0, 0, 445, + 447, 3, 12, 6, 0, 446, 445, 1, 0, 0, 0, 447, 450, 1, 0, 0, 0, 448, 446, + 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 11, 1, 0, 0, 0, 450, 448, 1, 0, + 0, 0, 451, 452, 5, 72, 0, 0, 452, 456, 3, 346, 173, 0, 453, 454, 5, 7, + 0, 0, 454, 457, 5, 15, 0, 0, 455, 457, 3, 14, 7, 0, 456, 453, 1, 0, 0, + 0, 456, 455, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 459, 1, 0, 0, 0, 458, + 460, 3, 148, 74, 0, 459, 458, 1, 0, 0, 0, 459, 460, 1, 0, 0, 0, 460, 13, + 1, 0, 0, 0, 461, 462, 5, 101, 0, 0, 462, 463, 3, 344, 172, 0, 463, 15, + 1, 0, 0, 0, 464, 466, 3, 20, 10, 0, 465, 467, 3, 150, 75, 0, 466, 465, + 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 17, 1, 0, 0, 0, 468, 470, 3, 300, + 150, 0, 469, 468, 1, 0, 0, 0, 469, 470, 1, 0, 0, 0, 470, 471, 1, 0, 0, + 0, 471, 475, 5, 79, 0, 0, 472, 474, 5, 5, 0, 0, 473, 472, 1, 0, 0, 0, 474, + 477, 1, 0, 0, 0, 475, 473, 1, 0, 0, 0, 475, 476, 1, 0, 0, 0, 476, 478, + 1, 0, 0, 0, 477, 475, 1, 0, 0, 0, 478, 486, 3, 344, 172, 0, 479, 481, 5, + 5, 0, 0, 480, 479, 1, 0, 0, 0, 481, 484, 1, 0, 0, 0, 482, 480, 1, 0, 0, + 0, 482, 483, 1, 0, 0, 0, 483, 485, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 485, + 487, 3, 42, 21, 0, 486, 482, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 491, + 1, 0, 0, 0, 488, 490, 5, 5, 0, 0, 489, 488, 1, 0, 0, 0, 490, 493, 1, 0, + 0, 0, 491, 489, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 494, 1, 0, 0, 0, + 493, 491, 1, 0, 0, 0, 494, 498, 5, 28, 0, 0, 495, 497, 5, 5, 0, 0, 496, + 495, 1, 0, 0, 0, 497, 500, 1, 0, 0, 0, 498, 496, 1, 0, 0, 0, 498, 499, + 1, 0, 0, 0, 499, 501, 1, 0, 0, 0, 500, 498, 1, 0, 0, 0, 501, 502, 3, 98, + 49, 0, 502, 19, 1, 0, 0, 0, 503, 509, 3, 22, 11, 0, 504, 509, 3, 86, 43, + 0, 505, 509, 3, 62, 31, 0, 506, 509, 3, 70, 35, 0, 507, 509, 3, 18, 9, + 0, 508, 503, 1, 0, 0, 0, 508, 504, 1, 0, 0, 0, 508, 505, 1, 0, 0, 0, 508, + 506, 1, 0, 0, 0, 508, 507, 1, 0, 0, 0, 509, 21, 1, 0, 0, 0, 510, 512, 3, + 300, 150, 0, 511, 510, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 524, 1, 0, + 0, 0, 513, 525, 5, 73, 0, 0, 514, 518, 5, 75, 0, 0, 515, 517, 5, 5, 0, + 0, 516, 515, 1, 0, 0, 0, 517, 520, 1, 0, 0, 0, 518, 516, 1, 0, 0, 0, 518, + 519, 1, 0, 0, 0, 519, 522, 1, 0, 0, 0, 520, 518, 1, 0, 0, 0, 521, 514, + 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 523, 1, 0, 0, 0, 523, 525, 5, 74, + 0, 0, 524, 513, 1, 0, 0, 0, 524, 521, 1, 0, 0, 0, 525, 529, 1, 0, 0, 0, + 526, 528, 5, 5, 0, 0, 527, 526, 1, 0, 0, 0, 528, 531, 1, 0, 0, 0, 529, + 527, 1, 0, 0, 0, 529, 530, 1, 0, 0, 0, 530, 532, 1, 0, 0, 0, 531, 529, + 1, 0, 0, 0, 532, 540, 3, 344, 172, 0, 533, 535, 5, 5, 0, 0, 534, 533, 1, + 0, 0, 0, 535, 538, 1, 0, 0, 0, 536, 534, 1, 0, 0, 0, 536, 537, 1, 0, 0, + 0, 537, 539, 1, 0, 0, 0, 538, 536, 1, 0, 0, 0, 539, 541, 3, 42, 21, 0, + 540, 536, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 549, 1, 0, 0, 0, 542, + 544, 5, 5, 0, 0, 543, 542, 1, 0, 0, 0, 544, 547, 1, 0, 0, 0, 545, 543, + 1, 0, 0, 0, 545, 546, 1, 0, 0, 0, 546, 548, 1, 0, 0, 0, 547, 545, 1, 0, + 0, 0, 548, 550, 3, 24, 12, 0, 549, 545, 1, 0, 0, 0, 549, 550, 1, 0, 0, + 0, 550, 565, 1, 0, 0, 0, 551, 553, 5, 5, 0, 0, 552, 551, 1, 0, 0, 0, 553, + 556, 1, 0, 0, 0, 554, 552, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 557, + 1, 0, 0, 0, 556, 554, 1, 0, 0, 0, 557, 561, 5, 26, 0, 0, 558, 560, 5, 5, + 0, 0, 559, 558, 1, 0, 0, 0, 560, 563, 1, 0, 0, 0, 561, 559, 1, 0, 0, 0, + 561, 562, 1, 0, 0, 0, 562, 564, 1, 0, 0, 0, 563, 561, 1, 0, 0, 0, 564, + 566, 3, 32, 16, 0, 565, 554, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, 566, 574, + 1, 0, 0, 0, 567, 569, 5, 5, 0, 0, 568, 567, 1, 0, 0, 0, 569, 572, 1, 0, + 0, 0, 570, 568, 1, 0, 0, 0, 570, 571, 1, 0, 0, 0, 571, 573, 1, 0, 0, 0, + 572, 570, 1, 0, 0, 0, 573, 575, 3, 46, 23, 0, 574, 570, 1, 0, 0, 0, 574, + 575, 1, 0, 0, 0, 575, 590, 1, 0, 0, 0, 576, 578, 5, 5, 0, 0, 577, 576, + 1, 0, 0, 0, 578, 581, 1, 0, 0, 0, 579, 577, 1, 0, 0, 0, 579, 580, 1, 0, + 0, 0, 580, 582, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 591, 3, 26, 13, + 0, 583, 585, 5, 5, 0, 0, 584, 583, 1, 0, 0, 0, 585, 588, 1, 0, 0, 0, 586, + 584, 1, 0, 0, 0, 586, 587, 1, 0, 0, 0, 587, 589, 1, 0, 0, 0, 588, 586, + 1, 0, 0, 0, 589, 591, 3, 92, 46, 0, 590, 579, 1, 0, 0, 0, 590, 586, 1, + 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 23, 1, 0, 0, 0, 592, 594, 3, 300, 150, + 0, 593, 592, 1, 0, 0, 0, 593, 594, 1, 0, 0, 0, 594, 595, 1, 0, 0, 0, 595, + 599, 5, 80, 0, 0, 596, 598, 5, 5, 0, 0, 597, 596, 1, 0, 0, 0, 598, 601, + 1, 0, 0, 0, 599, 597, 1, 0, 0, 0, 599, 600, 1, 0, 0, 0, 600, 603, 1, 0, + 0, 0, 601, 599, 1, 0, 0, 0, 602, 593, 1, 0, 0, 0, 602, 603, 1, 0, 0, 0, + 603, 604, 1, 0, 0, 0, 604, 605, 3, 28, 14, 0, 605, 25, 1, 0, 0, 0, 606, + 610, 5, 13, 0, 0, 607, 609, 5, 5, 0, 0, 608, 607, 1, 0, 0, 0, 609, 612, + 1, 0, 0, 0, 610, 608, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 613, 1, 0, + 0, 0, 612, 610, 1, 0, 0, 0, 613, 617, 3, 50, 25, 0, 614, 616, 5, 5, 0, + 0, 615, 614, 1, 0, 0, 0, 616, 619, 1, 0, 0, 0, 617, 615, 1, 0, 0, 0, 617, + 618, 1, 0, 0, 0, 618, 620, 1, 0, 0, 0, 619, 617, 1, 0, 0, 0, 620, 621, + 5, 14, 0, 0, 621, 27, 1, 0, 0, 0, 622, 626, 5, 9, 0, 0, 623, 625, 5, 5, + 0, 0, 624, 623, 1, 0, 0, 0, 625, 628, 1, 0, 0, 0, 626, 624, 1, 0, 0, 0, + 626, 627, 1, 0, 0, 0, 627, 658, 1, 0, 0, 0, 628, 626, 1, 0, 0, 0, 629, + 646, 3, 30, 15, 0, 630, 632, 5, 5, 0, 0, 631, 630, 1, 0, 0, 0, 632, 635, + 1, 0, 0, 0, 633, 631, 1, 0, 0, 0, 633, 634, 1, 0, 0, 0, 634, 636, 1, 0, + 0, 0, 635, 633, 1, 0, 0, 0, 636, 640, 5, 8, 0, 0, 637, 639, 5, 5, 0, 0, + 638, 637, 1, 0, 0, 0, 639, 642, 1, 0, 0, 0, 640, 638, 1, 0, 0, 0, 640, + 641, 1, 0, 0, 0, 641, 643, 1, 0, 0, 0, 642, 640, 1, 0, 0, 0, 643, 645, + 3, 30, 15, 0, 644, 633, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, + 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 656, 1, 0, 0, 0, 648, 646, 1, 0, 0, + 0, 649, 651, 5, 5, 0, 0, 650, 649, 1, 0, 0, 0, 651, 654, 1, 0, 0, 0, 652, + 650, 1, 0, 0, 0, 652, 653, 1, 0, 0, 0, 653, 655, 1, 0, 0, 0, 654, 652, + 1, 0, 0, 0, 655, 657, 5, 8, 0, 0, 656, 652, 1, 0, 0, 0, 656, 657, 1, 0, + 0, 0, 657, 659, 1, 0, 0, 0, 658, 629, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, + 659, 663, 1, 0, 0, 0, 660, 662, 5, 5, 0, 0, 661, 660, 1, 0, 0, 0, 662, + 665, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 666, + 1, 0, 0, 0, 665, 663, 1, 0, 0, 0, 666, 667, 5, 10, 0, 0, 667, 29, 1, 0, + 0, 0, 668, 670, 3, 300, 150, 0, 669, 668, 1, 0, 0, 0, 669, 670, 1, 0, 0, + 0, 670, 672, 1, 0, 0, 0, 671, 673, 7, 1, 0, 0, 672, 671, 1, 0, 0, 0, 672, + 673, 1, 0, 0, 0, 673, 677, 1, 0, 0, 0, 674, 676, 5, 5, 0, 0, 675, 674, + 1, 0, 0, 0, 676, 679, 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 677, 678, 1, 0, + 0, 0, 678, 680, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 680, 681, 3, 344, 172, + 0, 681, 685, 5, 26, 0, 0, 682, 684, 5, 5, 0, 0, 683, 682, 1, 0, 0, 0, 684, + 687, 1, 0, 0, 0, 685, 683, 1, 0, 0, 0, 685, 686, 1, 0, 0, 0, 686, 688, + 1, 0, 0, 0, 687, 685, 1, 0, 0, 0, 688, 703, 3, 98, 49, 0, 689, 691, 5, + 5, 0, 0, 690, 689, 1, 0, 0, 0, 691, 694, 1, 0, 0, 0, 692, 690, 1, 0, 0, + 0, 692, 693, 1, 0, 0, 0, 693, 695, 1, 0, 0, 0, 694, 692, 1, 0, 0, 0, 695, + 699, 5, 28, 0, 0, 696, 698, 5, 5, 0, 0, 697, 696, 1, 0, 0, 0, 698, 701, + 1, 0, 0, 0, 699, 697, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 702, 1, 0, + 0, 0, 701, 699, 1, 0, 0, 0, 702, 704, 3, 152, 76, 0, 703, 692, 1, 0, 0, + 0, 703, 704, 1, 0, 0, 0, 704, 31, 1, 0, 0, 0, 705, 722, 3, 38, 19, 0, 706, + 708, 5, 5, 0, 0, 707, 706, 1, 0, 0, 0, 708, 711, 1, 0, 0, 0, 709, 707, + 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 712, 1, 0, 0, 0, 711, 709, 1, 0, + 0, 0, 712, 716, 5, 8, 0, 0, 713, 715, 5, 5, 0, 0, 714, 713, 1, 0, 0, 0, + 715, 718, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, + 719, 1, 0, 0, 0, 718, 716, 1, 0, 0, 0, 719, 721, 3, 38, 19, 0, 720, 709, + 1, 0, 0, 0, 721, 724, 1, 0, 0, 0, 722, 720, 1, 0, 0, 0, 722, 723, 1, 0, + 0, 0, 723, 33, 1, 0, 0, 0, 724, 722, 1, 0, 0, 0, 725, 738, 3, 36, 18, 0, + 726, 738, 3, 40, 20, 0, 727, 738, 3, 106, 53, 0, 728, 738, 3, 116, 58, + 0, 729, 733, 5, 123, 0, 0, 730, 732, 5, 5, 0, 0, 731, 730, 1, 0, 0, 0, + 732, 735, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, + 736, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 736, 738, 3, 116, 58, 0, 737, 725, + 1, 0, 0, 0, 737, 726, 1, 0, 0, 0, 737, 727, 1, 0, 0, 0, 737, 728, 1, 0, + 0, 0, 737, 729, 1, 0, 0, 0, 738, 35, 1, 0, 0, 0, 739, 740, 3, 106, 53, + 0, 740, 741, 3, 208, 104, 0, 741, 37, 1, 0, 0, 0, 742, 744, 3, 334, 167, + 0, 743, 742, 1, 0, 0, 0, 744, 747, 1, 0, 0, 0, 745, 743, 1, 0, 0, 0, 745, + 746, 1, 0, 0, 0, 746, 751, 1, 0, 0, 0, 747, 745, 1, 0, 0, 0, 748, 750, + 5, 5, 0, 0, 749, 748, 1, 0, 0, 0, 750, 753, 1, 0, 0, 0, 751, 749, 1, 0, + 0, 0, 751, 752, 1, 0, 0, 0, 752, 754, 1, 0, 0, 0, 753, 751, 1, 0, 0, 0, + 754, 755, 3, 34, 17, 0, 755, 39, 1, 0, 0, 0, 756, 759, 3, 106, 53, 0, 757, + 759, 3, 116, 58, 0, 758, 756, 1, 0, 0, 0, 758, 757, 1, 0, 0, 0, 759, 763, + 1, 0, 0, 0, 760, 762, 5, 5, 0, 0, 761, 760, 1, 0, 0, 0, 762, 765, 1, 0, + 0, 0, 763, 761, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 766, 1, 0, 0, 0, + 765, 763, 1, 0, 0, 0, 766, 770, 5, 81, 0, 0, 767, 769, 5, 5, 0, 0, 768, + 767, 1, 0, 0, 0, 769, 772, 1, 0, 0, 0, 770, 768, 1, 0, 0, 0, 770, 771, + 1, 0, 0, 0, 771, 773, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 774, 3, 152, + 76, 0, 774, 41, 1, 0, 0, 0, 775, 779, 5, 46, 0, 0, 776, 778, 5, 5, 0, 0, + 777, 776, 1, 0, 0, 0, 778, 781, 1, 0, 0, 0, 779, 777, 1, 0, 0, 0, 779, + 780, 1, 0, 0, 0, 780, 782, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 799, + 3, 44, 22, 0, 783, 785, 5, 5, 0, 0, 784, 783, 1, 0, 0, 0, 785, 788, 1, + 0, 0, 0, 786, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 789, 1, 0, 0, + 0, 788, 786, 1, 0, 0, 0, 789, 793, 5, 8, 0, 0, 790, 792, 5, 5, 0, 0, 791, + 790, 1, 0, 0, 0, 792, 795, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 793, 794, + 1, 0, 0, 0, 794, 796, 1, 0, 0, 0, 795, 793, 1, 0, 0, 0, 796, 798, 3, 44, + 22, 0, 797, 786, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, + 799, 800, 1, 0, 0, 0, 800, 809, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, + 804, 5, 5, 0, 0, 803, 802, 1, 0, 0, 0, 804, 807, 1, 0, 0, 0, 805, 803, + 1, 0, 0, 0, 805, 806, 1, 0, 0, 0, 806, 808, 1, 0, 0, 0, 807, 805, 1, 0, + 0, 0, 808, 810, 5, 8, 0, 0, 809, 805, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, + 810, 814, 1, 0, 0, 0, 811, 813, 5, 5, 0, 0, 812, 811, 1, 0, 0, 0, 813, + 816, 1, 0, 0, 0, 814, 812, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 817, + 1, 0, 0, 0, 816, 814, 1, 0, 0, 0, 817, 818, 5, 47, 0, 0, 818, 43, 1, 0, + 0, 0, 819, 821, 3, 318, 159, 0, 820, 819, 1, 0, 0, 0, 820, 821, 1, 0, 0, + 0, 821, 825, 1, 0, 0, 0, 822, 824, 5, 5, 0, 0, 823, 822, 1, 0, 0, 0, 824, + 827, 1, 0, 0, 0, 825, 823, 1, 0, 0, 0, 825, 826, 1, 0, 0, 0, 826, 828, + 1, 0, 0, 0, 827, 825, 1, 0, 0, 0, 828, 843, 3, 344, 172, 0, 829, 831, 5, + 5, 0, 0, 830, 829, 1, 0, 0, 0, 831, 834, 1, 0, 0, 0, 832, 830, 1, 0, 0, + 0, 832, 833, 1, 0, 0, 0, 833, 835, 1, 0, 0, 0, 834, 832, 1, 0, 0, 0, 835, + 839, 5, 26, 0, 0, 836, 838, 5, 5, 0, 0, 837, 836, 1, 0, 0, 0, 838, 841, + 1, 0, 0, 0, 839, 837, 1, 0, 0, 0, 839, 840, 1, 0, 0, 0, 840, 842, 1, 0, + 0, 0, 841, 839, 1, 0, 0, 0, 842, 844, 3, 98, 49, 0, 843, 832, 1, 0, 0, + 0, 843, 844, 1, 0, 0, 0, 844, 45, 1, 0, 0, 0, 845, 849, 5, 87, 0, 0, 846, + 848, 5, 5, 0, 0, 847, 846, 1, 0, 0, 0, 848, 851, 1, 0, 0, 0, 849, 847, + 1, 0, 0, 0, 849, 850, 1, 0, 0, 0, 850, 852, 1, 0, 0, 0, 851, 849, 1, 0, + 0, 0, 852, 869, 3, 48, 24, 0, 853, 855, 5, 5, 0, 0, 854, 853, 1, 0, 0, + 0, 855, 858, 1, 0, 0, 0, 856, 854, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, + 859, 1, 0, 0, 0, 858, 856, 1, 0, 0, 0, 859, 863, 5, 8, 0, 0, 860, 862, + 5, 5, 0, 0, 861, 860, 1, 0, 0, 0, 862, 865, 1, 0, 0, 0, 863, 861, 1, 0, + 0, 0, 863, 864, 1, 0, 0, 0, 864, 866, 1, 0, 0, 0, 865, 863, 1, 0, 0, 0, + 866, 868, 3, 48, 24, 0, 867, 856, 1, 0, 0, 0, 868, 871, 1, 0, 0, 0, 869, + 867, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 47, 1, 0, 0, 0, 871, 869, 1, + 0, 0, 0, 872, 874, 3, 334, 167, 0, 873, 872, 1, 0, 0, 0, 874, 877, 1, 0, + 0, 0, 875, 873, 1, 0, 0, 0, 875, 876, 1, 0, 0, 0, 876, 878, 1, 0, 0, 0, + 877, 875, 1, 0, 0, 0, 878, 882, 3, 344, 172, 0, 879, 881, 5, 5, 0, 0, 880, + 879, 1, 0, 0, 0, 881, 884, 1, 0, 0, 0, 882, 880, 1, 0, 0, 0, 882, 883, + 1, 0, 0, 0, 883, 885, 1, 0, 0, 0, 884, 882, 1, 0, 0, 0, 885, 889, 5, 26, + 0, 0, 886, 888, 5, 5, 0, 0, 887, 886, 1, 0, 0, 0, 888, 891, 1, 0, 0, 0, + 889, 887, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 892, 1, 0, 0, 0, 891, + 889, 1, 0, 0, 0, 892, 893, 3, 98, 49, 0, 893, 49, 1, 0, 0, 0, 894, 896, + 3, 52, 26, 0, 895, 897, 3, 150, 75, 0, 896, 895, 1, 0, 0, 0, 896, 897, + 1, 0, 0, 0, 897, 899, 1, 0, 0, 0, 898, 894, 1, 0, 0, 0, 899, 902, 1, 0, + 0, 0, 900, 898, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 51, 1, 0, 0, 0, + 902, 900, 1, 0, 0, 0, 903, 908, 3, 20, 10, 0, 904, 908, 3, 56, 28, 0, 905, + 908, 3, 54, 27, 0, 906, 908, 3, 88, 44, 0, 907, 903, 1, 0, 0, 0, 907, 904, + 1, 0, 0, 0, 907, 905, 1, 0, 0, 0, 907, 906, 1, 0, 0, 0, 908, 53, 1, 0, + 0, 0, 909, 913, 5, 83, 0, 0, 910, 912, 5, 5, 0, 0, 911, 910, 1, 0, 0, 0, + 912, 915, 1, 0, 0, 0, 913, 911, 1, 0, 0, 0, 913, 914, 1, 0, 0, 0, 914, + 916, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 916, 917, 3, 136, 68, 0, 917, 55, + 1, 0, 0, 0, 918, 920, 3, 300, 150, 0, 919, 918, 1, 0, 0, 0, 919, 920, 1, + 0, 0, 0, 920, 921, 1, 0, 0, 0, 921, 925, 5, 82, 0, 0, 922, 924, 5, 5, 0, + 0, 923, 922, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 925, + 926, 1, 0, 0, 0, 926, 928, 1, 0, 0, 0, 927, 925, 1, 0, 0, 0, 928, 936, + 5, 76, 0, 0, 929, 931, 5, 5, 0, 0, 930, 929, 1, 0, 0, 0, 931, 934, 1, 0, + 0, 0, 932, 930, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 935, 1, 0, 0, 0, + 934, 932, 1, 0, 0, 0, 935, 937, 3, 344, 172, 0, 936, 932, 1, 0, 0, 0, 936, + 937, 1, 0, 0, 0, 937, 952, 1, 0, 0, 0, 938, 940, 5, 5, 0, 0, 939, 938, + 1, 0, 0, 0, 940, 943, 1, 0, 0, 0, 941, 939, 1, 0, 0, 0, 941, 942, 1, 0, + 0, 0, 942, 944, 1, 0, 0, 0, 943, 941, 1, 0, 0, 0, 944, 948, 5, 26, 0, 0, + 945, 947, 5, 5, 0, 0, 946, 945, 1, 0, 0, 0, 947, 950, 1, 0, 0, 0, 948, + 946, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 951, 1, 0, 0, 0, 950, 948, + 1, 0, 0, 0, 951, 953, 3, 32, 16, 0, 952, 941, 1, 0, 0, 0, 952, 953, 1, + 0, 0, 0, 953, 961, 1, 0, 0, 0, 954, 956, 5, 5, 0, 0, 955, 954, 1, 0, 0, + 0, 956, 959, 1, 0, 0, 0, 957, 955, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, + 960, 1, 0, 0, 0, 959, 957, 1, 0, 0, 0, 960, 962, 3, 26, 13, 0, 961, 957, + 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 57, 1, 0, 0, 0, 963, 967, 5, 9, + 0, 0, 964, 966, 5, 5, 0, 0, 965, 964, 1, 0, 0, 0, 966, 969, 1, 0, 0, 0, + 967, 965, 1, 0, 0, 0, 967, 968, 1, 0, 0, 0, 968, 999, 1, 0, 0, 0, 969, + 967, 1, 0, 0, 0, 970, 987, 3, 60, 30, 0, 971, 973, 5, 5, 0, 0, 972, 971, + 1, 0, 0, 0, 973, 976, 1, 0, 0, 0, 974, 972, 1, 0, 0, 0, 974, 975, 1, 0, + 0, 0, 975, 977, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 977, 981, 5, 8, 0, 0, + 978, 980, 5, 5, 0, 0, 979, 978, 1, 0, 0, 0, 980, 983, 1, 0, 0, 0, 981, + 979, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 984, 1, 0, 0, 0, 983, 981, + 1, 0, 0, 0, 984, 986, 3, 60, 30, 0, 985, 974, 1, 0, 0, 0, 986, 989, 1, + 0, 0, 0, 987, 985, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 997, 1, 0, 0, + 0, 989, 987, 1, 0, 0, 0, 990, 992, 5, 5, 0, 0, 991, 990, 1, 0, 0, 0, 992, + 995, 1, 0, 0, 0, 993, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 996, + 1, 0, 0, 0, 995, 993, 1, 0, 0, 0, 996, 998, 5, 8, 0, 0, 997, 993, 1, 0, + 0, 0, 997, 998, 1, 0, 0, 0, 998, 1000, 1, 0, 0, 0, 999, 970, 1, 0, 0, 0, + 999, 1000, 1, 0, 0, 0, 1000, 1004, 1, 0, 0, 0, 1001, 1003, 5, 5, 0, 0, + 1002, 1001, 1, 0, 0, 0, 1003, 1006, 1, 0, 0, 0, 1004, 1002, 1, 0, 0, 0, + 1004, 1005, 1, 0, 0, 0, 1005, 1007, 1, 0, 0, 0, 1006, 1004, 1, 0, 0, 0, + 1007, 1008, 5, 10, 0, 0, 1008, 59, 1, 0, 0, 0, 1009, 1011, 3, 302, 151, + 0, 1010, 1009, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 1, 0, 0, + 0, 1012, 1027, 3, 84, 42, 0, 1013, 1015, 5, 5, 0, 0, 1014, 1013, 1, 0, + 0, 0, 1015, 1018, 1, 0, 0, 0, 1016, 1014, 1, 0, 0, 0, 1016, 1017, 1, 0, + 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 1023, 5, 28, + 0, 0, 1020, 1022, 5, 5, 0, 0, 1021, 1020, 1, 0, 0, 0, 1022, 1025, 1, 0, + 0, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1026, 1, 0, + 0, 0, 1025, 1023, 1, 0, 0, 0, 1026, 1028, 3, 152, 76, 0, 1027, 1016, 1, + 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 61, 1, 0, 0, 0, 1029, 1031, 3, 300, + 150, 0, 1030, 1029, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1032, 1, + 0, 0, 0, 1032, 1040, 5, 75, 0, 0, 1033, 1035, 5, 5, 0, 0, 1034, 1033, 1, + 0, 0, 0, 1035, 1038, 1, 0, 0, 0, 1036, 1034, 1, 0, 0, 0, 1036, 1037, 1, + 0, 0, 0, 1037, 1039, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1039, 1041, 3, + 42, 21, 0, 1040, 1036, 1, 0, 0, 0, 1040, 1041, 1, 0, 0, 0, 1041, 1057, + 1, 0, 0, 0, 1042, 1044, 5, 5, 0, 0, 1043, 1042, 1, 0, 0, 0, 1044, 1047, + 1, 0, 0, 0, 1045, 1043, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1048, + 1, 0, 0, 0, 1047, 1045, 1, 0, 0, 0, 1048, 1052, 3, 122, 61, 0, 1049, 1051, + 5, 5, 0, 0, 1050, 1049, 1, 0, 0, 0, 1051, 1054, 1, 0, 0, 0, 1052, 1050, + 1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1052, + 1, 0, 0, 0, 1055, 1056, 5, 7, 0, 0, 1056, 1058, 1, 0, 0, 0, 1057, 1045, + 1, 0, 0, 0, 1057, 1058, 1, 0, 0, 0, 1058, 1062, 1, 0, 0, 0, 1059, 1061, + 5, 5, 0, 0, 1060, 1059, 1, 0, 0, 0, 1061, 1064, 1, 0, 0, 0, 1062, 1060, + 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1065, 1, 0, 0, 0, 1064, 1062, + 1, 0, 0, 0, 1065, 1069, 3, 344, 172, 0, 1066, 1068, 5, 5, 0, 0, 1067, 1066, + 1, 0, 0, 0, 1068, 1071, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1069, 1070, + 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1069, 1, 0, 0, 0, 1072, 1087, + 3, 58, 29, 0, 1073, 1075, 5, 5, 0, 0, 1074, 1073, 1, 0, 0, 0, 1075, 1078, + 1, 0, 0, 0, 1076, 1074, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 1079, + 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1079, 1083, 5, 26, 0, 0, 1080, 1082, + 5, 5, 0, 0, 1081, 1080, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1081, + 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1083, + 1, 0, 0, 0, 1086, 1088, 3, 98, 49, 0, 1087, 1076, 1, 0, 0, 0, 1087, 1088, + 1, 0, 0, 0, 1088, 1096, 1, 0, 0, 0, 1089, 1091, 5, 5, 0, 0, 1090, 1089, + 1, 0, 0, 0, 1091, 1094, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1092, 1093, + 1, 0, 0, 0, 1093, 1095, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1095, 1097, + 3, 46, 23, 0, 1096, 1092, 1, 0, 0, 0, 1096, 1097, 1, 0, 0, 0, 1097, 1105, + 1, 0, 0, 0, 1098, 1100, 5, 5, 0, 0, 1099, 1098, 1, 0, 0, 0, 1100, 1103, + 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1101, 1102, 1, 0, 0, 0, 1102, 1104, + 1, 0, 0, 0, 1103, 1101, 1, 0, 0, 0, 1104, 1106, 3, 64, 32, 0, 1105, 1101, + 1, 0, 0, 0, 1105, 1106, 1, 0, 0, 0, 1106, 63, 1, 0, 0, 0, 1107, 1117, 3, + 136, 68, 0, 1108, 1112, 5, 28, 0, 0, 1109, 1111, 5, 5, 0, 0, 1110, 1109, + 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, + 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1117, + 3, 152, 76, 0, 1116, 1107, 1, 0, 0, 0, 1116, 1108, 1, 0, 0, 0, 1117, 65, + 1, 0, 0, 0, 1118, 1120, 3, 334, 167, 0, 1119, 1118, 1, 0, 0, 0, 1120, 1123, + 1, 0, 0, 0, 1121, 1119, 1, 0, 0, 0, 1121, 1122, 1, 0, 0, 0, 1122, 1127, + 1, 0, 0, 0, 1123, 1121, 1, 0, 0, 0, 1124, 1126, 5, 5, 0, 0, 1125, 1124, + 1, 0, 0, 0, 1126, 1129, 1, 0, 0, 0, 1127, 1125, 1, 0, 0, 0, 1127, 1128, + 1, 0, 0, 0, 1128, 1130, 1, 0, 0, 0, 1129, 1127, 1, 0, 0, 0, 1130, 1145, + 3, 344, 172, 0, 1131, 1133, 5, 5, 0, 0, 1132, 1131, 1, 0, 0, 0, 1133, 1136, + 1, 0, 0, 0, 1134, 1132, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1137, + 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1137, 1141, 5, 26, 0, 0, 1138, 1140, + 5, 5, 0, 0, 1139, 1138, 1, 0, 0, 0, 1140, 1143, 1, 0, 0, 0, 1141, 1139, + 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 1144, 1, 0, 0, 0, 1143, 1141, + 1, 0, 0, 0, 1144, 1146, 3, 98, 49, 0, 1145, 1134, 1, 0, 0, 0, 1145, 1146, + 1, 0, 0, 0, 1146, 67, 1, 0, 0, 0, 1147, 1151, 5, 9, 0, 0, 1148, 1150, 5, + 5, 0, 0, 1149, 1148, 1, 0, 0, 0, 1150, 1153, 1, 0, 0, 0, 1151, 1149, 1, + 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1154, 1, 0, 0, 0, 1153, 1151, 1, + 0, 0, 0, 1154, 1171, 3, 66, 33, 0, 1155, 1157, 5, 5, 0, 0, 1156, 1155, + 1, 0, 0, 0, 1157, 1160, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1158, 1159, + 1, 0, 0, 0, 1159, 1161, 1, 0, 0, 0, 1160, 1158, 1, 0, 0, 0, 1161, 1165, + 5, 8, 0, 0, 1162, 1164, 5, 5, 0, 0, 1163, 1162, 1, 0, 0, 0, 1164, 1167, + 1, 0, 0, 0, 1165, 1163, 1, 0, 0, 0, 1165, 1166, 1, 0, 0, 0, 1166, 1168, + 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1168, 1170, 3, 66, 33, 0, 1169, 1158, + 1, 0, 0, 0, 1170, 1173, 1, 0, 0, 0, 1171, 1169, 1, 0, 0, 0, 1171, 1172, + 1, 0, 0, 0, 1172, 1181, 1, 0, 0, 0, 1173, 1171, 1, 0, 0, 0, 1174, 1176, + 5, 5, 0, 0, 1175, 1174, 1, 0, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1175, + 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 1180, 1, 0, 0, 0, 1179, 1177, + 1, 0, 0, 0, 1180, 1182, 5, 8, 0, 0, 1181, 1177, 1, 0, 0, 0, 1181, 1182, + 1, 0, 0, 0, 1182, 1186, 1, 0, 0, 0, 1183, 1185, 5, 5, 0, 0, 1184, 1183, + 1, 0, 0, 0, 1185, 1188, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, 1186, 1187, + 1, 0, 0, 0, 1187, 1189, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, 1189, 1190, + 5, 10, 0, 0, 1190, 69, 1, 0, 0, 0, 1191, 1193, 3, 300, 150, 0, 1192, 1191, + 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1202, + 7, 1, 0, 0, 1195, 1197, 5, 5, 0, 0, 1196, 1195, 1, 0, 0, 0, 1197, 1200, + 1, 0, 0, 0, 1198, 1196, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 1201, + 1, 0, 0, 0, 1200, 1198, 1, 0, 0, 0, 1201, 1203, 3, 42, 21, 0, 1202, 1198, + 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 1219, 1, 0, 0, 0, 1204, 1206, + 5, 5, 0, 0, 1205, 1204, 1, 0, 0, 0, 1206, 1209, 1, 0, 0, 0, 1207, 1205, + 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1210, 1, 0, 0, 0, 1209, 1207, + 1, 0, 0, 0, 1210, 1214, 3, 122, 61, 0, 1211, 1213, 5, 5, 0, 0, 1212, 1211, + 1, 0, 0, 0, 1213, 1216, 1, 0, 0, 0, 1214, 1212, 1, 0, 0, 0, 1214, 1215, + 1, 0, 0, 0, 1215, 1217, 1, 0, 0, 0, 1216, 1214, 1, 0, 0, 0, 1217, 1218, + 5, 7, 0, 0, 1218, 1220, 1, 0, 0, 0, 1219, 1207, 1, 0, 0, 0, 1219, 1220, + 1, 0, 0, 0, 1220, 1224, 1, 0, 0, 0, 1221, 1223, 5, 5, 0, 0, 1222, 1221, + 1, 0, 0, 0, 1223, 1226, 1, 0, 0, 0, 1224, 1222, 1, 0, 0, 0, 1224, 1225, + 1, 0, 0, 0, 1225, 1229, 1, 0, 0, 0, 1226, 1224, 1, 0, 0, 0, 1227, 1230, + 3, 68, 34, 0, 1228, 1230, 3, 66, 33, 0, 1229, 1227, 1, 0, 0, 0, 1229, 1228, + 1, 0, 0, 0, 1230, 1238, 1, 0, 0, 0, 1231, 1233, 5, 5, 0, 0, 1232, 1231, + 1, 0, 0, 0, 1233, 1236, 1, 0, 0, 0, 1234, 1232, 1, 0, 0, 0, 1234, 1235, + 1, 0, 0, 0, 1235, 1237, 1, 0, 0, 0, 1236, 1234, 1, 0, 0, 0, 1237, 1239, + 3, 46, 23, 0, 1238, 1234, 1, 0, 0, 0, 1238, 1239, 1, 0, 0, 0, 1239, 1257, + 1, 0, 0, 0, 1240, 1242, 5, 5, 0, 0, 1241, 1240, 1, 0, 0, 0, 1242, 1245, + 1, 0, 0, 0, 1243, 1241, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1255, + 1, 0, 0, 0, 1245, 1243, 1, 0, 0, 0, 1246, 1250, 5, 28, 0, 0, 1247, 1249, + 5, 5, 0, 0, 1248, 1247, 1, 0, 0, 0, 1249, 1252, 1, 0, 0, 0, 1250, 1248, + 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1253, 1, 0, 0, 0, 1252, 1250, + 1, 0, 0, 0, 1253, 1256, 3, 152, 76, 0, 1254, 1256, 3, 72, 36, 0, 1255, + 1246, 1, 0, 0, 0, 1255, 1254, 1, 0, 0, 0, 1256, 1258, 1, 0, 0, 0, 1257, + 1243, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1265, 1, 0, 0, 0, 1259, + 1261, 5, 5, 0, 0, 1260, 1259, 1, 0, 0, 0, 1261, 1262, 1, 0, 0, 0, 1262, + 1260, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, + 1266, 5, 27, 0, 0, 1265, 1260, 1, 0, 0, 0, 1265, 1266, 1, 0, 0, 0, 1266, + 1270, 1, 0, 0, 0, 1267, 1269, 5, 5, 0, 0, 1268, 1267, 1, 0, 0, 0, 1269, + 1272, 1, 0, 0, 0, 1270, 1268, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, + 1303, 1, 0, 0, 0, 1272, 1270, 1, 0, 0, 0, 1273, 1275, 3, 74, 37, 0, 1274, + 1273, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1286, 1, 0, 0, 0, 1276, + 1278, 5, 5, 0, 0, 1277, 1276, 1, 0, 0, 0, 1278, 1281, 1, 0, 0, 0, 1279, + 1277, 1, 0, 0, 0, 1279, 1280, 1, 0, 0, 0, 1280, 1283, 1, 0, 0, 0, 1281, + 1279, 1, 0, 0, 0, 1282, 1284, 3, 148, 74, 0, 1283, 1282, 1, 0, 0, 0, 1283, + 1284, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 3, 76, 38, 0, 1286, + 1279, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 1304, 1, 0, 0, 0, 1288, + 1290, 3, 76, 38, 0, 1289, 1288, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, + 1301, 1, 0, 0, 0, 1291, 1293, 5, 5, 0, 0, 1292, 1291, 1, 0, 0, 0, 1293, + 1296, 1, 0, 0, 0, 1294, 1292, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, + 1298, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1297, 1299, 3, 148, 74, 0, 1298, + 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, + 1302, 3, 74, 37, 0, 1301, 1294, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, + 1304, 1, 0, 0, 0, 1303, 1274, 1, 0, 0, 0, 1303, 1289, 1, 0, 0, 0, 1304, + 71, 1, 0, 0, 0, 1305, 1309, 5, 81, 0, 0, 1306, 1308, 5, 5, 0, 0, 1307, + 1306, 1, 0, 0, 0, 1308, 1311, 1, 0, 0, 0, 1309, 1307, 1, 0, 0, 0, 1309, + 1310, 1, 0, 0, 0, 1310, 1312, 1, 0, 0, 0, 1311, 1309, 1, 0, 0, 0, 1312, + 1313, 3, 152, 76, 0, 1313, 73, 1, 0, 0, 0, 1314, 1316, 3, 300, 150, 0, + 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, + 1317, 1355, 5, 65, 0, 0, 1318, 1320, 5, 5, 0, 0, 1319, 1318, 1, 0, 0, 0, + 1320, 1323, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, + 1322, 1324, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1324, 1328, 5, 9, 0, 0, + 1325, 1327, 5, 5, 0, 0, 1326, 1325, 1, 0, 0, 0, 1327, 1330, 1, 0, 0, 0, + 1328, 1326, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1331, 1, 0, 0, 0, + 1330, 1328, 1, 0, 0, 0, 1331, 1346, 5, 10, 0, 0, 1332, 1334, 5, 5, 0, 0, + 1333, 1332, 1, 0, 0, 0, 1334, 1337, 1, 0, 0, 0, 1335, 1333, 1, 0, 0, 0, + 1335, 1336, 1, 0, 0, 0, 1336, 1338, 1, 0, 0, 0, 1337, 1335, 1, 0, 0, 0, + 1338, 1342, 5, 26, 0, 0, 1339, 1341, 5, 5, 0, 0, 1340, 1339, 1, 0, 0, 0, + 1341, 1344, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, + 1343, 1345, 1, 0, 0, 0, 1344, 1342, 1, 0, 0, 0, 1345, 1347, 3, 98, 49, + 0, 1346, 1335, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1351, 1, 0, 0, + 0, 1348, 1350, 5, 5, 0, 0, 1349, 1348, 1, 0, 0, 0, 1350, 1353, 1, 0, 0, + 0, 1351, 1349, 1, 0, 0, 0, 1351, 1352, 1, 0, 0, 0, 1352, 1354, 1, 0, 0, + 0, 1353, 1351, 1, 0, 0, 0, 1354, 1356, 3, 64, 32, 0, 1355, 1321, 1, 0, + 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 75, 1, 0, 0, 0, 1357, 1359, 3, 300, + 150, 0, 1358, 1357, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, 1359, 1360, 1, + 0, 0, 0, 1360, 1415, 5, 66, 0, 0, 1361, 1363, 5, 5, 0, 0, 1362, 1361, 1, + 0, 0, 0, 1363, 1366, 1, 0, 0, 0, 1364, 1362, 1, 0, 0, 0, 1364, 1365, 1, + 0, 0, 0, 1365, 1367, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1371, 5, + 9, 0, 0, 1368, 1370, 5, 5, 0, 0, 1369, 1368, 1, 0, 0, 0, 1370, 1373, 1, + 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 1, + 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 1382, 3, 80, 40, 0, 1375, 1377, + 5, 5, 0, 0, 1376, 1375, 1, 0, 0, 0, 1377, 1380, 1, 0, 0, 0, 1378, 1376, + 1, 0, 0, 0, 1378, 1379, 1, 0, 0, 0, 1379, 1381, 1, 0, 0, 0, 1380, 1378, + 1, 0, 0, 0, 1381, 1383, 5, 8, 0, 0, 1382, 1378, 1, 0, 0, 0, 1382, 1383, + 1, 0, 0, 0, 1383, 1387, 1, 0, 0, 0, 1384, 1386, 5, 5, 0, 0, 1385, 1384, + 1, 0, 0, 0, 1386, 1389, 1, 0, 0, 0, 1387, 1385, 1, 0, 0, 0, 1387, 1388, + 1, 0, 0, 0, 1388, 1390, 1, 0, 0, 0, 1389, 1387, 1, 0, 0, 0, 1390, 1405, + 5, 10, 0, 0, 1391, 1393, 5, 5, 0, 0, 1392, 1391, 1, 0, 0, 0, 1393, 1396, + 1, 0, 0, 0, 1394, 1392, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, 0, 1395, 1397, + 1, 0, 0, 0, 1396, 1394, 1, 0, 0, 0, 1397, 1401, 5, 26, 0, 0, 1398, 1400, + 5, 5, 0, 0, 1399, 1398, 1, 0, 0, 0, 1400, 1403, 1, 0, 0, 0, 1401, 1399, + 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0, 1402, 1404, 1, 0, 0, 0, 1403, 1401, + 1, 0, 0, 0, 1404, 1406, 3, 98, 49, 0, 1405, 1394, 1, 0, 0, 0, 1405, 1406, + 1, 0, 0, 0, 1406, 1410, 1, 0, 0, 0, 1407, 1409, 5, 5, 0, 0, 1408, 1407, + 1, 0, 0, 0, 1409, 1412, 1, 0, 0, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1411, + 1, 0, 0, 0, 1411, 1413, 1, 0, 0, 0, 1412, 1410, 1, 0, 0, 0, 1413, 1414, + 3, 64, 32, 0, 1414, 1416, 1, 0, 0, 0, 1415, 1364, 1, 0, 0, 0, 1415, 1416, + 1, 0, 0, 0, 1416, 77, 1, 0, 0, 0, 1417, 1421, 5, 9, 0, 0, 1418, 1420, 5, + 5, 0, 0, 1419, 1418, 1, 0, 0, 0, 1420, 1423, 1, 0, 0, 0, 1421, 1419, 1, + 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 1453, 1, 0, 0, 0, 1423, 1421, 1, + 0, 0, 0, 1424, 1441, 3, 80, 40, 0, 1425, 1427, 5, 5, 0, 0, 1426, 1425, + 1, 0, 0, 0, 1427, 1430, 1, 0, 0, 0, 1428, 1426, 1, 0, 0, 0, 1428, 1429, + 1, 0, 0, 0, 1429, 1431, 1, 0, 0, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1435, + 5, 8, 0, 0, 1432, 1434, 5, 5, 0, 0, 1433, 1432, 1, 0, 0, 0, 1434, 1437, + 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1438, + 1, 0, 0, 0, 1437, 1435, 1, 0, 0, 0, 1438, 1440, 3, 80, 40, 0, 1439, 1428, + 1, 0, 0, 0, 1440, 1443, 1, 0, 0, 0, 1441, 1439, 1, 0, 0, 0, 1441, 1442, + 1, 0, 0, 0, 1442, 1451, 1, 0, 0, 0, 1443, 1441, 1, 0, 0, 0, 1444, 1446, + 5, 5, 0, 0, 1445, 1444, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, 1445, + 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, 1447, + 1, 0, 0, 0, 1450, 1452, 5, 8, 0, 0, 1451, 1447, 1, 0, 0, 0, 1451, 1452, + 1, 0, 0, 0, 1452, 1454, 1, 0, 0, 0, 1453, 1424, 1, 0, 0, 0, 1453, 1454, + 1, 0, 0, 0, 1454, 1458, 1, 0, 0, 0, 1455, 1457, 5, 5, 0, 0, 1456, 1455, + 1, 0, 0, 0, 1457, 1460, 1, 0, 0, 0, 1458, 1456, 1, 0, 0, 0, 1458, 1459, + 1, 0, 0, 0, 1459, 1461, 1, 0, 0, 0, 1460, 1458, 1, 0, 0, 0, 1461, 1462, + 5, 10, 0, 0, 1462, 79, 1, 0, 0, 0, 1463, 1465, 3, 302, 151, 0, 1464, 1463, + 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1481, + 3, 82, 41, 0, 1467, 1469, 5, 5, 0, 0, 1468, 1467, 1, 0, 0, 0, 1469, 1472, + 1, 0, 0, 0, 1470, 1468, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 1473, + 1, 0, 0, 0, 1472, 1470, 1, 0, 0, 0, 1473, 1477, 5, 28, 0, 0, 1474, 1476, + 5, 5, 0, 0, 1475, 1474, 1, 0, 0, 0, 1476, 1479, 1, 0, 0, 0, 1477, 1475, + 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1480, 1, 0, 0, 0, 1479, 1477, + 1, 0, 0, 0, 1480, 1482, 3, 152, 76, 0, 1481, 1470, 1, 0, 0, 0, 1481, 1482, + 1, 0, 0, 0, 1482, 81, 1, 0, 0, 0, 1483, 1487, 3, 344, 172, 0, 1484, 1486, + 5, 5, 0, 0, 1485, 1484, 1, 0, 0, 0, 1486, 1489, 1, 0, 0, 0, 1487, 1485, + 1, 0, 0, 0, 1487, 1488, 1, 0, 0, 0, 1488, 1498, 1, 0, 0, 0, 1489, 1487, + 1, 0, 0, 0, 1490, 1494, 5, 26, 0, 0, 1491, 1493, 5, 5, 0, 0, 1492, 1491, + 1, 0, 0, 0, 1493, 1496, 1, 0, 0, 0, 1494, 1492, 1, 0, 0, 0, 1494, 1495, + 1, 0, 0, 0, 1495, 1497, 1, 0, 0, 0, 1496, 1494, 1, 0, 0, 0, 1497, 1499, + 3, 98, 49, 0, 1498, 1490, 1, 0, 0, 0, 1498, 1499, 1, 0, 0, 0, 1499, 83, + 1, 0, 0, 0, 1500, 1504, 3, 344, 172, 0, 1501, 1503, 5, 5, 0, 0, 1502, 1501, + 1, 0, 0, 0, 1503, 1506, 1, 0, 0, 0, 1504, 1502, 1, 0, 0, 0, 1504, 1505, + 1, 0, 0, 0, 1505, 1507, 1, 0, 0, 0, 1506, 1504, 1, 0, 0, 0, 1507, 1511, + 5, 26, 0, 0, 1508, 1510, 5, 5, 0, 0, 1509, 1508, 1, 0, 0, 0, 1510, 1513, + 1, 0, 0, 0, 1511, 1509, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1514, + 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1514, 1515, 3, 98, 49, 0, 1515, 85, + 1, 0, 0, 0, 1516, 1518, 3, 300, 150, 0, 1517, 1516, 1, 0, 0, 0, 1517, 1518, + 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1523, 5, 76, 0, 0, 1520, 1522, + 5, 5, 0, 0, 1521, 1520, 1, 0, 0, 0, 1522, 1525, 1, 0, 0, 0, 1523, 1521, + 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 1526, 1, 0, 0, 0, 1525, 1523, + 1, 0, 0, 0, 1526, 1541, 3, 344, 172, 0, 1527, 1529, 5, 5, 0, 0, 1528, 1527, + 1, 0, 0, 0, 1529, 1532, 1, 0, 0, 0, 1530, 1528, 1, 0, 0, 0, 1530, 1531, + 1, 0, 0, 0, 1531, 1533, 1, 0, 0, 0, 1532, 1530, 1, 0, 0, 0, 1533, 1537, + 5, 26, 0, 0, 1534, 1536, 5, 5, 0, 0, 1535, 1534, 1, 0, 0, 0, 1536, 1539, + 1, 0, 0, 0, 1537, 1535, 1, 0, 0, 0, 1537, 1538, 1, 0, 0, 0, 1538, 1540, + 1, 0, 0, 0, 1539, 1537, 1, 0, 0, 0, 1540, 1542, 3, 32, 16, 0, 1541, 1530, + 1, 0, 0, 0, 1541, 1542, 1, 0, 0, 0, 1542, 1550, 1, 0, 0, 0, 1543, 1545, + 5, 5, 0, 0, 1544, 1543, 1, 0, 0, 0, 1545, 1548, 1, 0, 0, 0, 1546, 1544, + 1, 0, 0, 0, 1546, 1547, 1, 0, 0, 0, 1547, 1549, 1, 0, 0, 0, 1548, 1546, + 1, 0, 0, 0, 1549, 1551, 3, 26, 13, 0, 1550, 1546, 1, 0, 0, 0, 1550, 1551, + 1, 0, 0, 0, 1551, 87, 1, 0, 0, 0, 1552, 1554, 3, 300, 150, 0, 1553, 1552, + 1, 0, 0, 0, 1553, 1554, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1559, + 5, 80, 0, 0, 1556, 1558, 5, 5, 0, 0, 1557, 1556, 1, 0, 0, 0, 1558, 1561, + 1, 0, 0, 0, 1559, 1557, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1562, + 1, 0, 0, 0, 1561, 1559, 1, 0, 0, 0, 1562, 1577, 3, 58, 29, 0, 1563, 1565, + 5, 5, 0, 0, 1564, 1563, 1, 0, 0, 0, 1565, 1568, 1, 0, 0, 0, 1566, 1564, + 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1569, 1, 0, 0, 0, 1568, 1566, + 1, 0, 0, 0, 1569, 1573, 5, 26, 0, 0, 1570, 1572, 5, 5, 0, 0, 1571, 1570, + 1, 0, 0, 0, 1572, 1575, 1, 0, 0, 0, 1573, 1571, 1, 0, 0, 0, 1573, 1574, + 1, 0, 0, 0, 1574, 1576, 1, 0, 0, 0, 1575, 1573, 1, 0, 0, 0, 1576, 1578, + 3, 90, 45, 0, 1577, 1566, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1582, + 1, 0, 0, 0, 1579, 1581, 5, 5, 0, 0, 1580, 1579, 1, 0, 0, 0, 1581, 1584, + 1, 0, 0, 0, 1582, 1580, 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1586, + 1, 0, 0, 0, 1584, 1582, 1, 0, 0, 0, 1585, 1587, 3, 136, 68, 0, 1586, 1585, + 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 89, 1, 0, 0, 0, 1588, 1592, 7, + 2, 0, 0, 1589, 1591, 5, 5, 0, 0, 1590, 1589, 1, 0, 0, 0, 1591, 1594, 1, + 0, 0, 0, 1592, 1590, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 1595, 1, + 0, 0, 0, 1594, 1592, 1, 0, 0, 0, 1595, 1596, 3, 208, 104, 0, 1596, 91, + 1, 0, 0, 0, 1597, 1601, 5, 13, 0, 0, 1598, 1600, 5, 5, 0, 0, 1599, 1598, + 1, 0, 0, 0, 1600, 1603, 1, 0, 0, 0, 1601, 1599, 1, 0, 0, 0, 1601, 1602, + 1, 0, 0, 0, 1602, 1605, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1604, 1606, + 3, 94, 47, 0, 1605, 1604, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1621, + 1, 0, 0, 0, 1607, 1609, 5, 5, 0, 0, 1608, 1607, 1, 0, 0, 0, 1609, 1612, + 1, 0, 0, 0, 1610, 1608, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1613, + 1, 0, 0, 0, 1612, 1610, 1, 0, 0, 0, 1613, 1617, 5, 27, 0, 0, 1614, 1616, + 5, 5, 0, 0, 1615, 1614, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, + 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1617, + 1, 0, 0, 0, 1620, 1622, 3, 50, 25, 0, 1621, 1610, 1, 0, 0, 0, 1621, 1622, + 1, 0, 0, 0, 1622, 1626, 1, 0, 0, 0, 1623, 1625, 5, 5, 0, 0, 1624, 1623, + 1, 0, 0, 0, 1625, 1628, 1, 0, 0, 0, 1626, 1624, 1, 0, 0, 0, 1626, 1627, + 1, 0, 0, 0, 1627, 1629, 1, 0, 0, 0, 1628, 1626, 1, 0, 0, 0, 1629, 1630, + 5, 14, 0, 0, 1630, 93, 1, 0, 0, 0, 1631, 1648, 3, 96, 48, 0, 1632, 1634, + 5, 5, 0, 0, 1633, 1632, 1, 0, 0, 0, 1634, 1637, 1, 0, 0, 0, 1635, 1633, + 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 1638, 1, 0, 0, 0, 1637, 1635, + 1, 0, 0, 0, 1638, 1642, 5, 8, 0, 0, 1639, 1641, 5, 5, 0, 0, 1640, 1639, + 1, 0, 0, 0, 1641, 1644, 1, 0, 0, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1643, + 1, 0, 0, 0, 1643, 1645, 1, 0, 0, 0, 1644, 1642, 1, 0, 0, 0, 1645, 1647, + 3, 96, 48, 0, 1646, 1635, 1, 0, 0, 0, 1647, 1650, 1, 0, 0, 0, 1648, 1646, + 1, 0, 0, 0, 1648, 1649, 1, 0, 0, 0, 1649, 1654, 1, 0, 0, 0, 1650, 1648, + 1, 0, 0, 0, 1651, 1653, 5, 5, 0, 0, 1652, 1651, 1, 0, 0, 0, 1653, 1656, + 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1658, + 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1659, 5, 8, 0, 0, 1658, 1657, + 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 95, 1, 0, 0, 0, 1660, 1664, 3, + 300, 150, 0, 1661, 1663, 5, 5, 0, 0, 1662, 1661, 1, 0, 0, 0, 1663, 1666, + 1, 0, 0, 0, 1664, 1662, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 1668, + 1, 0, 0, 0, 1666, 1664, 1, 0, 0, 0, 1667, 1660, 1, 0, 0, 0, 1667, 1668, + 1, 0, 0, 0, 1668, 1669, 1, 0, 0, 0, 1669, 1677, 3, 344, 172, 0, 1670, 1672, + 5, 5, 0, 0, 1671, 1670, 1, 0, 0, 0, 1672, 1675, 1, 0, 0, 0, 1673, 1671, + 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1676, 1, 0, 0, 0, 1675, 1673, + 1, 0, 0, 0, 1676, 1678, 3, 208, 104, 0, 1677, 1673, 1, 0, 0, 0, 1677, 1678, + 1, 0, 0, 0, 1678, 1686, 1, 0, 0, 0, 1679, 1681, 5, 5, 0, 0, 1680, 1679, + 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, + 1, 0, 0, 0, 1683, 1685, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1685, 1687, + 3, 26, 13, 0, 1686, 1682, 1, 0, 0, 0, 1686, 1687, 1, 0, 0, 0, 1687, 97, + 1, 0, 0, 0, 1688, 1690, 3, 306, 153, 0, 1689, 1688, 1, 0, 0, 0, 1689, 1690, + 1, 0, 0, 0, 1690, 1696, 1, 0, 0, 0, 1691, 1697, 3, 116, 58, 0, 1692, 1697, + 3, 120, 60, 0, 1693, 1697, 3, 102, 51, 0, 1694, 1697, 3, 100, 50, 0, 1695, + 1697, 3, 126, 63, 0, 1696, 1691, 1, 0, 0, 0, 1696, 1692, 1, 0, 0, 0, 1696, + 1693, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1696, 1695, 1, 0, 0, 0, 1697, + 99, 1, 0, 0, 0, 1698, 1701, 3, 106, 53, 0, 1699, 1701, 5, 107, 0, 0, 1700, + 1698, 1, 0, 0, 0, 1700, 1699, 1, 0, 0, 0, 1701, 101, 1, 0, 0, 0, 1702, + 1705, 3, 100, 50, 0, 1703, 1705, 3, 120, 60, 0, 1704, 1702, 1, 0, 0, 0, + 1704, 1703, 1, 0, 0, 0, 1705, 1709, 1, 0, 0, 0, 1706, 1708, 5, 5, 0, 0, + 1707, 1706, 1, 0, 0, 0, 1708, 1711, 1, 0, 0, 0, 1709, 1707, 1, 0, 0, 0, + 1709, 1710, 1, 0, 0, 0, 1710, 1713, 1, 0, 0, 0, 1711, 1709, 1, 0, 0, 0, + 1712, 1714, 3, 104, 52, 0, 1713, 1712, 1, 0, 0, 0, 1714, 1715, 1, 0, 0, + 0, 1715, 1713, 1, 0, 0, 0, 1715, 1716, 1, 0, 0, 0, 1716, 103, 1, 0, 0, + 0, 1717, 1718, 7, 3, 0, 0, 1718, 105, 1, 0, 0, 0, 1719, 1736, 3, 108, 54, + 0, 1720, 1722, 5, 5, 0, 0, 1721, 1720, 1, 0, 0, 0, 1722, 1725, 1, 0, 0, + 0, 1723, 1721, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1726, 1, 0, 0, + 0, 1725, 1723, 1, 0, 0, 0, 1726, 1730, 5, 7, 0, 0, 1727, 1729, 5, 5, 0, + 0, 1728, 1727, 1, 0, 0, 0, 1729, 1732, 1, 0, 0, 0, 1730, 1728, 1, 0, 0, + 0, 1730, 1731, 1, 0, 0, 0, 1731, 1733, 1, 0, 0, 0, 1732, 1730, 1, 0, 0, + 0, 1733, 1735, 3, 108, 54, 0, 1734, 1723, 1, 0, 0, 0, 1735, 1738, 1, 0, + 0, 0, 1736, 1734, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 107, 1, 0, + 0, 0, 1738, 1736, 1, 0, 0, 0, 1739, 1747, 3, 344, 172, 0, 1740, 1742, 5, + 5, 0, 0, 1741, 1740, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, + 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, + 0, 0, 0, 1746, 1748, 3, 206, 103, 0, 1747, 1743, 1, 0, 0, 0, 1747, 1748, + 1, 0, 0, 0, 1748, 109, 1, 0, 0, 0, 1749, 1751, 3, 112, 56, 0, 1750, 1749, + 1, 0, 0, 0, 1750, 1751, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1755, + 3, 98, 49, 0, 1753, 1755, 5, 15, 0, 0, 1754, 1750, 1, 0, 0, 0, 1754, 1753, + 1, 0, 0, 0, 1755, 111, 1, 0, 0, 0, 1756, 1758, 3, 114, 57, 0, 1757, 1756, + 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1757, 1, 0, 0, 0, 1759, 1760, + 1, 0, 0, 0, 1760, 113, 1, 0, 0, 0, 1761, 1765, 3, 316, 158, 0, 1762, 1764, + 5, 5, 0, 0, 1763, 1762, 1, 0, 0, 0, 1764, 1767, 1, 0, 0, 0, 1765, 1763, + 1, 0, 0, 0, 1765, 1766, 1, 0, 0, 0, 1766, 1770, 1, 0, 0, 0, 1767, 1765, + 1, 0, 0, 0, 1768, 1770, 3, 334, 167, 0, 1769, 1761, 1, 0, 0, 0, 1769, 1768, + 1, 0, 0, 0, 1770, 115, 1, 0, 0, 0, 1771, 1775, 3, 122, 61, 0, 1772, 1774, + 5, 5, 0, 0, 1773, 1772, 1, 0, 0, 0, 1774, 1777, 1, 0, 0, 0, 1775, 1773, + 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1778, 1, 0, 0, 0, 1777, 1775, + 1, 0, 0, 0, 1778, 1782, 5, 7, 0, 0, 1779, 1781, 5, 5, 0, 0, 1780, 1779, + 1, 0, 0, 0, 1781, 1784, 1, 0, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1783, + 1, 0, 0, 0, 1783, 1786, 1, 0, 0, 0, 1784, 1782, 1, 0, 0, 0, 1785, 1771, + 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1791, + 3, 118, 59, 0, 1788, 1790, 5, 5, 0, 0, 1789, 1788, 1, 0, 0, 0, 1790, 1793, + 1, 0, 0, 0, 1791, 1789, 1, 0, 0, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1794, + 1, 0, 0, 0, 1793, 1791, 1, 0, 0, 0, 1794, 1798, 5, 34, 0, 0, 1795, 1797, + 5, 5, 0, 0, 1796, 1795, 1, 0, 0, 0, 1797, 1800, 1, 0, 0, 0, 1798, 1796, + 1, 0, 0, 0, 1798, 1799, 1, 0, 0, 0, 1799, 1801, 1, 0, 0, 0, 1800, 1798, + 1, 0, 0, 0, 1801, 1802, 3, 98, 49, 0, 1802, 117, 1, 0, 0, 0, 1803, 1807, + 5, 9, 0, 0, 1804, 1806, 5, 5, 0, 0, 1805, 1804, 1, 0, 0, 0, 1806, 1809, + 1, 0, 0, 0, 1807, 1805, 1, 0, 0, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1812, + 1, 0, 0, 0, 1809, 1807, 1, 0, 0, 0, 1810, 1813, 3, 84, 42, 0, 1811, 1813, + 3, 98, 49, 0, 1812, 1810, 1, 0, 0, 0, 1812, 1811, 1, 0, 0, 0, 1812, 1813, + 1, 0, 0, 0, 1813, 1833, 1, 0, 0, 0, 1814, 1816, 5, 5, 0, 0, 1815, 1814, + 1, 0, 0, 0, 1816, 1819, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1818, + 1, 0, 0, 0, 1818, 1820, 1, 0, 0, 0, 1819, 1817, 1, 0, 0, 0, 1820, 1824, + 5, 8, 0, 0, 1821, 1823, 5, 5, 0, 0, 1822, 1821, 1, 0, 0, 0, 1823, 1826, + 1, 0, 0, 0, 1824, 1822, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1829, + 1, 0, 0, 0, 1826, 1824, 1, 0, 0, 0, 1827, 1830, 3, 84, 42, 0, 1828, 1830, + 3, 98, 49, 0, 1829, 1827, 1, 0, 0, 0, 1829, 1828, 1, 0, 0, 0, 1830, 1832, + 1, 0, 0, 0, 1831, 1817, 1, 0, 0, 0, 1832, 1835, 1, 0, 0, 0, 1833, 1831, + 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1843, 1, 0, 0, 0, 1835, 1833, + 1, 0, 0, 0, 1836, 1838, 5, 5, 0, 0, 1837, 1836, 1, 0, 0, 0, 1838, 1841, + 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1842, + 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1842, 1844, 5, 8, 0, 0, 1843, 1839, + 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1848, 1, 0, 0, 0, 1845, 1847, + 5, 5, 0, 0, 1846, 1845, 1, 0, 0, 0, 1847, 1850, 1, 0, 0, 0, 1848, 1846, + 1, 0, 0, 0, 1848, 1849, 1, 0, 0, 0, 1849, 1851, 1, 0, 0, 0, 1850, 1848, + 1, 0, 0, 0, 1851, 1852, 5, 10, 0, 0, 1852, 119, 1, 0, 0, 0, 1853, 1857, + 5, 9, 0, 0, 1854, 1856, 5, 5, 0, 0, 1855, 1854, 1, 0, 0, 0, 1856, 1859, + 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1860, + 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1860, 1864, 3, 98, 49, 0, 1861, 1863, + 5, 5, 0, 0, 1862, 1861, 1, 0, 0, 0, 1863, 1866, 1, 0, 0, 0, 1864, 1862, + 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1867, 1, 0, 0, 0, 1866, 1864, + 1, 0, 0, 0, 1867, 1868, 5, 10, 0, 0, 1868, 121, 1, 0, 0, 0, 1869, 1871, + 3, 306, 153, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1875, + 1, 0, 0, 0, 1872, 1876, 3, 120, 60, 0, 1873, 1876, 3, 102, 51, 0, 1874, + 1876, 3, 100, 50, 0, 1875, 1872, 1, 0, 0, 0, 1875, 1873, 1, 0, 0, 0, 1875, + 1874, 1, 0, 0, 0, 1876, 123, 1, 0, 0, 0, 1877, 1881, 5, 9, 0, 0, 1878, + 1880, 5, 5, 0, 0, 1879, 1878, 1, 0, 0, 0, 1880, 1883, 1, 0, 0, 0, 1881, + 1879, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1886, 1, 0, 0, 0, 1883, + 1881, 1, 0, 0, 0, 1884, 1887, 3, 106, 53, 0, 1885, 1887, 3, 124, 62, 0, + 1886, 1884, 1, 0, 0, 0, 1886, 1885, 1, 0, 0, 0, 1887, 1891, 1, 0, 0, 0, + 1888, 1890, 5, 5, 0, 0, 1889, 1888, 1, 0, 0, 0, 1890, 1893, 1, 0, 0, 0, + 1891, 1889, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1894, 1, 0, 0, 0, + 1893, 1891, 1, 0, 0, 0, 1894, 1895, 5, 10, 0, 0, 1895, 125, 1, 0, 0, 0, + 1896, 1898, 3, 306, 153, 0, 1897, 1896, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, + 0, 1898, 1901, 1, 0, 0, 0, 1899, 1902, 3, 106, 53, 0, 1900, 1902, 3, 124, + 62, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1900, 1, 0, 0, 0, 1902, 1906, 1, 0, + 0, 0, 1903, 1905, 5, 5, 0, 0, 1904, 1903, 1, 0, 0, 0, 1905, 1908, 1, 0, + 0, 0, 1906, 1904, 1, 0, 0, 0, 1906, 1907, 1, 0, 0, 0, 1907, 1909, 1, 0, + 0, 0, 1908, 1906, 1, 0, 0, 0, 1909, 1913, 5, 56, 0, 0, 1910, 1912, 5, 5, + 0, 0, 1911, 1910, 1, 0, 0, 0, 1912, 1915, 1, 0, 0, 0, 1913, 1911, 1, 0, + 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 1917, 1, 0, 0, 0, 1915, 1913, 1, 0, + 0, 0, 1916, 1918, 3, 306, 153, 0, 1917, 1916, 1, 0, 0, 0, 1917, 1918, 1, + 0, 0, 0, 1918, 1921, 1, 0, 0, 0, 1919, 1922, 3, 106, 53, 0, 1920, 1922, + 3, 124, 62, 0, 1921, 1919, 1, 0, 0, 0, 1921, 1920, 1, 0, 0, 0, 1922, 127, + 1, 0, 0, 0, 1923, 1929, 3, 130, 65, 0, 1924, 1925, 3, 150, 75, 0, 1925, + 1926, 3, 130, 65, 0, 1926, 1928, 1, 0, 0, 0, 1927, 1924, 1, 0, 0, 0, 1928, + 1931, 1, 0, 0, 0, 1929, 1927, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, + 1933, 1, 0, 0, 0, 1931, 1929, 1, 0, 0, 0, 1932, 1923, 1, 0, 0, 0, 1932, + 1933, 1, 0, 0, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1936, 3, 150, 75, 0, 1935, + 1934, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0, 1936, 129, 1, 0, 0, 0, 1937, + 1940, 3, 132, 66, 0, 1938, 1940, 3, 334, 167, 0, 1939, 1937, 1, 0, 0, 0, + 1939, 1938, 1, 0, 0, 0, 1940, 1943, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, + 1941, 1942, 1, 0, 0, 0, 1942, 1948, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, + 1944, 1949, 3, 20, 10, 0, 1945, 1949, 3, 146, 73, 0, 1946, 1949, 3, 138, + 69, 0, 1947, 1949, 3, 152, 76, 0, 1948, 1944, 1, 0, 0, 0, 1948, 1945, 1, + 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1948, 1947, 1, 0, 0, 0, 1949, 131, 1, + 0, 0, 0, 1950, 1951, 3, 344, 172, 0, 1951, 1955, 7, 4, 0, 0, 1952, 1954, + 5, 5, 0, 0, 1953, 1952, 1, 0, 0, 0, 1954, 1957, 1, 0, 0, 0, 1955, 1953, + 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 133, 1, 0, 0, 0, 1957, 1955, + 1, 0, 0, 0, 1958, 1961, 3, 136, 68, 0, 1959, 1961, 3, 130, 65, 0, 1960, + 1958, 1, 0, 0, 0, 1960, 1959, 1, 0, 0, 0, 1961, 135, 1, 0, 0, 0, 1962, + 1966, 5, 13, 0, 0, 1963, 1965, 5, 5, 0, 0, 1964, 1963, 1, 0, 0, 0, 1965, + 1968, 1, 0, 0, 0, 1966, 1964, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, + 1969, 1, 0, 0, 0, 1968, 1966, 1, 0, 0, 0, 1969, 1973, 3, 128, 64, 0, 1970, + 1972, 5, 5, 0, 0, 1971, 1970, 1, 0, 0, 0, 1972, 1975, 1, 0, 0, 0, 1973, + 1971, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1976, 1, 0, 0, 0, 1975, + 1973, 1, 0, 0, 0, 1976, 1977, 5, 14, 0, 0, 1977, 137, 1, 0, 0, 0, 1978, + 1982, 3, 140, 70, 0, 1979, 1982, 3, 142, 71, 0, 1980, 1982, 3, 144, 72, + 0, 1981, 1978, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1981, 1980, 1, 0, 0, + 0, 1982, 139, 1, 0, 0, 0, 1983, 1987, 5, 94, 0, 0, 1984, 1986, 5, 5, 0, + 0, 1985, 1984, 1, 0, 0, 0, 1986, 1989, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, + 0, 1987, 1988, 1, 0, 0, 0, 1988, 1990, 1, 0, 0, 0, 1989, 1987, 1, 0, 0, + 0, 1990, 1994, 5, 9, 0, 0, 1991, 1993, 3, 334, 167, 0, 1992, 1991, 1, 0, + 0, 0, 1993, 1996, 1, 0, 0, 0, 1994, 1992, 1, 0, 0, 0, 1994, 1995, 1, 0, + 0, 0, 1995, 1999, 1, 0, 0, 0, 1996, 1994, 1, 0, 0, 0, 1997, 2000, 3, 66, + 33, 0, 1998, 2000, 3, 68, 34, 0, 1999, 1997, 1, 0, 0, 0, 1999, 1998, 1, + 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2002, 5, 103, 0, 0, 2002, 2003, + 3, 152, 76, 0, 2003, 2007, 5, 10, 0, 0, 2004, 2006, 5, 5, 0, 0, 2005, 2004, + 1, 0, 0, 0, 2006, 2009, 1, 0, 0, 0, 2007, 2005, 1, 0, 0, 0, 2007, 2008, + 1, 0, 0, 0, 2008, 2011, 1, 0, 0, 0, 2009, 2007, 1, 0, 0, 0, 2010, 2012, + 3, 134, 67, 0, 2011, 2010, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 141, + 1, 0, 0, 0, 2013, 2017, 5, 96, 0, 0, 2014, 2016, 5, 5, 0, 0, 2015, 2014, + 1, 0, 0, 0, 2016, 2019, 1, 0, 0, 0, 2017, 2015, 1, 0, 0, 0, 2017, 2018, + 1, 0, 0, 0, 2018, 2020, 1, 0, 0, 0, 2019, 2017, 1, 0, 0, 0, 2020, 2021, + 5, 9, 0, 0, 2021, 2022, 3, 152, 76, 0, 2022, 2026, 5, 10, 0, 0, 2023, 2025, + 5, 5, 0, 0, 2024, 2023, 1, 0, 0, 0, 2025, 2028, 1, 0, 0, 0, 2026, 2024, + 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 2031, 1, 0, 0, 0, 2028, 2026, + 1, 0, 0, 0, 2029, 2032, 3, 134, 67, 0, 2030, 2032, 5, 27, 0, 0, 2031, 2029, + 1, 0, 0, 0, 2031, 2030, 1, 0, 0, 0, 2032, 143, 1, 0, 0, 0, 2033, 2037, + 5, 95, 0, 0, 2034, 2036, 5, 5, 0, 0, 2035, 2034, 1, 0, 0, 0, 2036, 2039, + 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2041, + 1, 0, 0, 0, 2039, 2037, 1, 0, 0, 0, 2040, 2042, 3, 134, 67, 0, 2041, 2040, + 1, 0, 0, 0, 2041, 2042, 1, 0, 0, 0, 2042, 2046, 1, 0, 0, 0, 2043, 2045, + 5, 5, 0, 0, 2044, 2043, 1, 0, 0, 0, 2045, 2048, 1, 0, 0, 0, 2046, 2044, + 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2049, 1, 0, 0, 0, 2048, 2046, + 1, 0, 0, 0, 2049, 2053, 5, 96, 0, 0, 2050, 2052, 5, 5, 0, 0, 2051, 2050, + 1, 0, 0, 0, 2052, 2055, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2053, 2054, + 1, 0, 0, 0, 2054, 2056, 1, 0, 0, 0, 2055, 2053, 1, 0, 0, 0, 2056, 2057, + 5, 9, 0, 0, 2057, 2058, 3, 152, 76, 0, 2058, 2059, 5, 10, 0, 0, 2059, 145, + 1, 0, 0, 0, 2060, 2061, 3, 188, 94, 0, 2061, 2062, 5, 28, 0, 0, 2062, 2067, + 1, 0, 0, 0, 2063, 2064, 3, 192, 96, 0, 2064, 2065, 3, 274, 137, 0, 2065, + 2067, 1, 0, 0, 0, 2066, 2060, 1, 0, 0, 0, 2066, 2063, 1, 0, 0, 0, 2067, + 2071, 1, 0, 0, 0, 2068, 2070, 5, 5, 0, 0, 2069, 2068, 1, 0, 0, 0, 2070, + 2073, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, + 2074, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2074, 2075, 3, 152, 76, 0, 2075, + 147, 1, 0, 0, 0, 2076, 2080, 7, 5, 0, 0, 2077, 2079, 5, 5, 0, 0, 2078, + 2077, 1, 0, 0, 0, 2079, 2082, 1, 0, 0, 0, 2080, 2078, 1, 0, 0, 0, 2080, + 2081, 1, 0, 0, 0, 2081, 149, 1, 0, 0, 0, 2082, 2080, 1, 0, 0, 0, 2083, + 2085, 7, 5, 0, 0, 2084, 2083, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, + 2084, 1, 0, 0, 0, 2086, 2087, 1, 0, 0, 0, 2087, 151, 1, 0, 0, 0, 2088, + 2089, 3, 154, 77, 0, 2089, 153, 1, 0, 0, 0, 2090, 2107, 3, 156, 78, 0, + 2091, 2093, 5, 5, 0, 0, 2092, 2091, 1, 0, 0, 0, 2093, 2096, 1, 0, 0, 0, + 2094, 2092, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 2097, 1, 0, 0, 0, + 2096, 2094, 1, 0, 0, 0, 2097, 2101, 5, 23, 0, 0, 2098, 2100, 5, 5, 0, 0, + 2099, 2098, 1, 0, 0, 0, 2100, 2103, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, + 2101, 2102, 1, 0, 0, 0, 2102, 2104, 1, 0, 0, 0, 2103, 2101, 1, 0, 0, 0, + 2104, 2106, 3, 156, 78, 0, 2105, 2094, 1, 0, 0, 0, 2106, 2109, 1, 0, 0, + 0, 2107, 2105, 1, 0, 0, 0, 2107, 2108, 1, 0, 0, 0, 2108, 155, 1, 0, 0, + 0, 2109, 2107, 1, 0, 0, 0, 2110, 2127, 3, 158, 79, 0, 2111, 2113, 5, 5, + 0, 0, 2112, 2111, 1, 0, 0, 0, 2113, 2116, 1, 0, 0, 0, 2114, 2112, 1, 0, + 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2117, 1, 0, 0, 0, 2116, 2114, 1, 0, + 0, 0, 2117, 2121, 5, 22, 0, 0, 2118, 2120, 5, 5, 0, 0, 2119, 2118, 1, 0, + 0, 0, 2120, 2123, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2121, 2122, 1, 0, + 0, 0, 2122, 2124, 1, 0, 0, 0, 2123, 2121, 1, 0, 0, 0, 2124, 2126, 3, 158, + 79, 0, 2125, 2114, 1, 0, 0, 0, 2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, + 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 157, 1, 0, 0, 0, 2129, 2127, 1, 0, + 0, 0, 2130, 2142, 3, 160, 80, 0, 2131, 2135, 3, 276, 138, 0, 2132, 2134, + 5, 5, 0, 0, 2133, 2132, 1, 0, 0, 0, 2134, 2137, 1, 0, 0, 0, 2135, 2133, + 1, 0, 0, 0, 2135, 2136, 1, 0, 0, 0, 2136, 2138, 1, 0, 0, 0, 2137, 2135, + 1, 0, 0, 0, 2138, 2139, 3, 160, 80, 0, 2139, 2141, 1, 0, 0, 0, 2140, 2131, + 1, 0, 0, 0, 2141, 2144, 1, 0, 0, 0, 2142, 2140, 1, 0, 0, 0, 2142, 2143, + 1, 0, 0, 0, 2143, 159, 1, 0, 0, 0, 2144, 2142, 1, 0, 0, 0, 2145, 2157, + 3, 162, 81, 0, 2146, 2150, 3, 278, 139, 0, 2147, 2149, 5, 5, 0, 0, 2148, + 2147, 1, 0, 0, 0, 2149, 2152, 1, 0, 0, 0, 2150, 2148, 1, 0, 0, 0, 2150, + 2151, 1, 0, 0, 0, 2151, 2153, 1, 0, 0, 0, 2152, 2150, 1, 0, 0, 0, 2153, + 2154, 3, 162, 81, 0, 2154, 2156, 1, 0, 0, 0, 2155, 2146, 1, 0, 0, 0, 2156, + 2159, 1, 0, 0, 0, 2157, 2155, 1, 0, 0, 0, 2157, 2158, 1, 0, 0, 0, 2158, + 161, 1, 0, 0, 0, 2159, 2157, 1, 0, 0, 0, 2160, 2164, 3, 164, 82, 0, 2161, + 2163, 3, 202, 101, 0, 2162, 2161, 1, 0, 0, 0, 2163, 2166, 1, 0, 0, 0, 2164, + 2162, 1, 0, 0, 0, 2164, 2165, 1, 0, 0, 0, 2165, 163, 1, 0, 0, 0, 2166, + 2164, 1, 0, 0, 0, 2167, 2188, 3, 166, 83, 0, 2168, 2172, 3, 280, 140, 0, + 2169, 2171, 5, 5, 0, 0, 2170, 2169, 1, 0, 0, 0, 2171, 2174, 1, 0, 0, 0, + 2172, 2170, 1, 0, 0, 0, 2172, 2173, 1, 0, 0, 0, 2173, 2175, 1, 0, 0, 0, + 2174, 2172, 1, 0, 0, 0, 2175, 2176, 3, 166, 83, 0, 2176, 2187, 1, 0, 0, + 0, 2177, 2181, 3, 282, 141, 0, 2178, 2180, 5, 5, 0, 0, 2179, 2178, 1, 0, + 0, 0, 2180, 2183, 1, 0, 0, 0, 2181, 2179, 1, 0, 0, 0, 2181, 2182, 1, 0, + 0, 0, 2182, 2184, 1, 0, 0, 0, 2183, 2181, 1, 0, 0, 0, 2184, 2185, 3, 98, + 49, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2168, 1, 0, 0, 0, 2186, 2177, 1, 0, + 0, 0, 2187, 2190, 1, 0, 0, 0, 2188, 2186, 1, 0, 0, 0, 2188, 2189, 1, 0, + 0, 0, 2189, 165, 1, 0, 0, 0, 2190, 2188, 1, 0, 0, 0, 2191, 2209, 3, 170, + 85, 0, 2192, 2194, 5, 5, 0, 0, 2193, 2192, 1, 0, 0, 0, 2194, 2197, 1, 0, + 0, 0, 2195, 2193, 1, 0, 0, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2198, 1, 0, + 0, 0, 2197, 2195, 1, 0, 0, 0, 2198, 2202, 3, 168, 84, 0, 2199, 2201, 5, + 5, 0, 0, 2200, 2199, 1, 0, 0, 0, 2201, 2204, 1, 0, 0, 0, 2202, 2200, 1, + 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2205, 1, 0, 0, 0, 2204, 2202, 1, + 0, 0, 0, 2205, 2206, 3, 170, 85, 0, 2206, 2208, 1, 0, 0, 0, 2207, 2195, + 1, 0, 0, 0, 2208, 2211, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2209, 2210, + 1, 0, 0, 0, 2210, 167, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2212, 2213, + 5, 45, 0, 0, 2213, 2214, 5, 26, 0, 0, 2214, 169, 1, 0, 0, 0, 2215, 2227, + 3, 172, 86, 0, 2216, 2220, 3, 344, 172, 0, 2217, 2219, 5, 5, 0, 0, 2218, + 2217, 1, 0, 0, 0, 2219, 2222, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2220, + 2221, 1, 0, 0, 0, 2221, 2223, 1, 0, 0, 0, 2222, 2220, 1, 0, 0, 0, 2223, + 2224, 3, 172, 86, 0, 2224, 2226, 1, 0, 0, 0, 2225, 2216, 1, 0, 0, 0, 2226, + 2229, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, + 171, 1, 0, 0, 0, 2229, 2227, 1, 0, 0, 0, 2230, 2241, 3, 174, 87, 0, 2231, + 2235, 5, 36, 0, 0, 2232, 2234, 5, 5, 0, 0, 2233, 2232, 1, 0, 0, 0, 2234, + 2237, 1, 0, 0, 0, 2235, 2233, 1, 0, 0, 0, 2235, 2236, 1, 0, 0, 0, 2236, + 2238, 1, 0, 0, 0, 2237, 2235, 1, 0, 0, 0, 2238, 2240, 3, 174, 87, 0, 2239, + 2231, 1, 0, 0, 0, 2240, 2243, 1, 0, 0, 0, 2241, 2239, 1, 0, 0, 0, 2241, + 2242, 1, 0, 0, 0, 2242, 173, 1, 0, 0, 0, 2243, 2241, 1, 0, 0, 0, 2244, + 2256, 3, 176, 88, 0, 2245, 2249, 3, 284, 142, 0, 2246, 2248, 5, 5, 0, 0, + 2247, 2246, 1, 0, 0, 0, 2248, 2251, 1, 0, 0, 0, 2249, 2247, 1, 0, 0, 0, + 2249, 2250, 1, 0, 0, 0, 2250, 2252, 1, 0, 0, 0, 2251, 2249, 1, 0, 0, 0, + 2252, 2253, 3, 176, 88, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2245, 1, 0, 0, + 0, 2255, 2258, 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, + 0, 2257, 175, 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2271, 3, 178, 89, + 0, 2260, 2264, 3, 286, 143, 0, 2261, 2263, 5, 5, 0, 0, 2262, 2261, 1, 0, + 0, 0, 2263, 2266, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2264, 2265, 1, 0, + 0, 0, 2265, 2267, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2267, 2268, 3, 178, + 89, 0, 2268, 2270, 1, 0, 0, 0, 2269, 2260, 1, 0, 0, 0, 2270, 2273, 1, 0, + 0, 0, 2271, 2269, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 177, 1, 0, + 0, 0, 2273, 2271, 1, 0, 0, 0, 2274, 2292, 3, 180, 90, 0, 2275, 2277, 5, + 5, 0, 0, 2276, 2275, 1, 0, 0, 0, 2277, 2280, 1, 0, 0, 0, 2278, 2276, 1, + 0, 0, 0, 2278, 2279, 1, 0, 0, 0, 2279, 2281, 1, 0, 0, 0, 2280, 2278, 1, + 0, 0, 0, 2281, 2285, 3, 288, 144, 0, 2282, 2284, 5, 5, 0, 0, 2283, 2282, + 1, 0, 0, 0, 2284, 2287, 1, 0, 0, 0, 2285, 2283, 1, 0, 0, 0, 2285, 2286, + 1, 0, 0, 0, 2286, 2288, 1, 0, 0, 0, 2287, 2285, 1, 0, 0, 0, 2288, 2289, + 3, 98, 49, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2278, 1, 0, 0, 0, 2291, 2294, + 1, 0, 0, 0, 2292, 2290, 1, 0, 0, 0, 2292, 2293, 1, 0, 0, 0, 2293, 179, + 1, 0, 0, 0, 2294, 2292, 1, 0, 0, 0, 2295, 2297, 3, 182, 91, 0, 2296, 2295, + 1, 0, 0, 0, 2297, 2300, 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2298, 2299, + 1, 0, 0, 0, 2299, 2301, 1, 0, 0, 0, 2300, 2298, 1, 0, 0, 0, 2301, 2302, + 3, 184, 92, 0, 2302, 181, 1, 0, 0, 0, 2303, 2313, 3, 334, 167, 0, 2304, + 2313, 3, 132, 66, 0, 2305, 2309, 3, 290, 145, 0, 2306, 2308, 5, 5, 0, 0, + 2307, 2306, 1, 0, 0, 0, 2308, 2311, 1, 0, 0, 0, 2309, 2307, 1, 0, 0, 0, + 2309, 2310, 1, 0, 0, 0, 2310, 2313, 1, 0, 0, 0, 2311, 2309, 1, 0, 0, 0, + 2312, 2303, 1, 0, 0, 0, 2312, 2304, 1, 0, 0, 0, 2312, 2305, 1, 0, 0, 0, + 2313, 183, 1, 0, 0, 0, 2314, 2318, 3, 212, 106, 0, 2315, 2317, 3, 186, + 93, 0, 2316, 2315, 1, 0, 0, 0, 2317, 2320, 1, 0, 0, 0, 2318, 2316, 1, 0, + 0, 0, 2318, 2319, 1, 0, 0, 0, 2319, 185, 1, 0, 0, 0, 2320, 2318, 1, 0, + 0, 0, 2321, 2327, 3, 292, 146, 0, 2322, 2327, 3, 206, 103, 0, 2323, 2327, + 3, 202, 101, 0, 2324, 2327, 3, 198, 99, 0, 2325, 2327, 3, 200, 100, 0, + 2326, 2321, 1, 0, 0, 0, 2326, 2322, 1, 0, 0, 0, 2326, 2323, 1, 0, 0, 0, + 2326, 2324, 1, 0, 0, 0, 2326, 2325, 1, 0, 0, 0, 2327, 187, 1, 0, 0, 0, + 2328, 2329, 3, 184, 92, 0, 2329, 2330, 3, 196, 98, 0, 2330, 2334, 1, 0, + 0, 0, 2331, 2334, 3, 344, 172, 0, 2332, 2334, 3, 190, 95, 0, 2333, 2328, + 1, 0, 0, 0, 2333, 2331, 1, 0, 0, 0, 2333, 2332, 1, 0, 0, 0, 2334, 189, + 1, 0, 0, 0, 2335, 2339, 5, 9, 0, 0, 2336, 2338, 5, 5, 0, 0, 2337, 2336, + 1, 0, 0, 0, 2338, 2341, 1, 0, 0, 0, 2339, 2337, 1, 0, 0, 0, 2339, 2340, + 1, 0, 0, 0, 2340, 2342, 1, 0, 0, 0, 2341, 2339, 1, 0, 0, 0, 2342, 2346, + 3, 188, 94, 0, 2343, 2345, 5, 5, 0, 0, 2344, 2343, 1, 0, 0, 0, 2345, 2348, + 1, 0, 0, 0, 2346, 2344, 1, 0, 0, 0, 2346, 2347, 1, 0, 0, 0, 2347, 2349, + 1, 0, 0, 0, 2348, 2346, 1, 0, 0, 0, 2349, 2350, 5, 10, 0, 0, 2350, 191, + 1, 0, 0, 0, 2351, 2354, 3, 180, 90, 0, 2352, 2354, 3, 194, 97, 0, 2353, + 2351, 1, 0, 0, 0, 2353, 2352, 1, 0, 0, 0, 2354, 193, 1, 0, 0, 0, 2355, + 2359, 5, 9, 0, 0, 2356, 2358, 5, 5, 0, 0, 2357, 2356, 1, 0, 0, 0, 2358, + 2361, 1, 0, 0, 0, 2359, 2357, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, + 2362, 1, 0, 0, 0, 2361, 2359, 1, 0, 0, 0, 2362, 2366, 3, 192, 96, 0, 2363, + 2365, 5, 5, 0, 0, 2364, 2363, 1, 0, 0, 0, 2365, 2368, 1, 0, 0, 0, 2366, + 2364, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2369, 1, 0, 0, 0, 2368, + 2366, 1, 0, 0, 0, 2369, 2370, 5, 10, 0, 0, 2370, 195, 1, 0, 0, 0, 2371, + 2375, 3, 206, 103, 0, 2372, 2375, 3, 198, 99, 0, 2373, 2375, 3, 200, 100, + 0, 2374, 2371, 1, 0, 0, 0, 2374, 2372, 1, 0, 0, 0, 2374, 2373, 1, 0, 0, + 0, 2375, 197, 1, 0, 0, 0, 2376, 2380, 5, 11, 0, 0, 2377, 2379, 5, 5, 0, + 0, 2378, 2377, 1, 0, 0, 0, 2379, 2382, 1, 0, 0, 0, 2380, 2378, 1, 0, 0, + 0, 2380, 2381, 1, 0, 0, 0, 2381, 2383, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, + 0, 2383, 2400, 3, 152, 76, 0, 2384, 2386, 5, 5, 0, 0, 2385, 2384, 1, 0, + 0, 0, 2386, 2389, 1, 0, 0, 0, 2387, 2385, 1, 0, 0, 0, 2387, 2388, 1, 0, + 0, 0, 2388, 2390, 1, 0, 0, 0, 2389, 2387, 1, 0, 0, 0, 2390, 2394, 5, 8, + 0, 0, 2391, 2393, 5, 5, 0, 0, 2392, 2391, 1, 0, 0, 0, 2393, 2396, 1, 0, + 0, 0, 2394, 2392, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2397, 1, 0, + 0, 0, 2396, 2394, 1, 0, 0, 0, 2397, 2399, 3, 152, 76, 0, 2398, 2387, 1, + 0, 0, 0, 2399, 2402, 1, 0, 0, 0, 2400, 2398, 1, 0, 0, 0, 2400, 2401, 1, + 0, 0, 0, 2401, 2410, 1, 0, 0, 0, 2402, 2400, 1, 0, 0, 0, 2403, 2405, 5, + 5, 0, 0, 2404, 2403, 1, 0, 0, 0, 2405, 2408, 1, 0, 0, 0, 2406, 2404, 1, + 0, 0, 0, 2406, 2407, 1, 0, 0, 0, 2407, 2409, 1, 0, 0, 0, 2408, 2406, 1, + 0, 0, 0, 2409, 2411, 5, 8, 0, 0, 2410, 2406, 1, 0, 0, 0, 2410, 2411, 1, + 0, 0, 0, 2411, 2415, 1, 0, 0, 0, 2412, 2414, 5, 5, 0, 0, 2413, 2412, 1, + 0, 0, 0, 2414, 2417, 1, 0, 0, 0, 2415, 2413, 1, 0, 0, 0, 2415, 2416, 1, + 0, 0, 0, 2416, 2418, 1, 0, 0, 0, 2417, 2415, 1, 0, 0, 0, 2418, 2419, 5, + 12, 0, 0, 2419, 199, 1, 0, 0, 0, 2420, 2424, 3, 296, 148, 0, 2421, 2423, + 5, 5, 0, 0, 2422, 2421, 1, 0, 0, 0, 2423, 2426, 1, 0, 0, 0, 2424, 2422, + 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2430, 1, 0, 0, 0, 2426, 2424, + 1, 0, 0, 0, 2427, 2431, 3, 344, 172, 0, 2428, 2431, 3, 214, 107, 0, 2429, + 2431, 5, 73, 0, 0, 2430, 2427, 1, 0, 0, 0, 2430, 2428, 1, 0, 0, 0, 2430, + 2429, 1, 0, 0, 0, 2431, 201, 1, 0, 0, 0, 2432, 2434, 3, 206, 103, 0, 2433, + 2432, 1, 0, 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2440, 1, 0, 0, 0, 2435, + 2437, 3, 208, 104, 0, 2436, 2435, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, + 2438, 1, 0, 0, 0, 2438, 2441, 3, 204, 102, 0, 2439, 2441, 3, 208, 104, + 0, 2440, 2436, 1, 0, 0, 0, 2440, 2439, 1, 0, 0, 0, 2441, 203, 1, 0, 0, + 0, 2442, 2444, 3, 334, 167, 0, 2443, 2442, 1, 0, 0, 0, 2444, 2447, 1, 0, + 0, 0, 2445, 2443, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2449, 1, 0, + 0, 0, 2447, 2445, 1, 0, 0, 0, 2448, 2450, 3, 132, 66, 0, 2449, 2448, 1, + 0, 0, 0, 2449, 2450, 1, 0, 0, 0, 2450, 2454, 1, 0, 0, 0, 2451, 2453, 5, + 5, 0, 0, 2452, 2451, 1, 0, 0, 0, 2453, 2456, 1, 0, 0, 0, 2454, 2452, 1, + 0, 0, 0, 2454, 2455, 1, 0, 0, 0, 2455, 2457, 1, 0, 0, 0, 2456, 2454, 1, + 0, 0, 0, 2457, 2458, 3, 234, 117, 0, 2458, 205, 1, 0, 0, 0, 2459, 2463, + 5, 46, 0, 0, 2460, 2462, 5, 5, 0, 0, 2461, 2460, 1, 0, 0, 0, 2462, 2465, + 1, 0, 0, 0, 2463, 2461, 1, 0, 0, 0, 2463, 2464, 1, 0, 0, 0, 2464, 2466, + 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2466, 2483, 3, 110, 55, 0, 2467, 2469, + 5, 5, 0, 0, 2468, 2467, 1, 0, 0, 0, 2469, 2472, 1, 0, 0, 0, 2470, 2468, + 1, 0, 0, 0, 2470, 2471, 1, 0, 0, 0, 2471, 2473, 1, 0, 0, 0, 2472, 2470, + 1, 0, 0, 0, 2473, 2477, 5, 8, 0, 0, 2474, 2476, 5, 5, 0, 0, 2475, 2474, + 1, 0, 0, 0, 2476, 2479, 1, 0, 0, 0, 2477, 2475, 1, 0, 0, 0, 2477, 2478, + 1, 0, 0, 0, 2478, 2480, 1, 0, 0, 0, 2479, 2477, 1, 0, 0, 0, 2480, 2482, + 3, 110, 55, 0, 2481, 2470, 1, 0, 0, 0, 2482, 2485, 1, 0, 0, 0, 2483, 2481, + 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2493, 1, 0, 0, 0, 2485, 2483, + 1, 0, 0, 0, 2486, 2488, 5, 5, 0, 0, 2487, 2486, 1, 0, 0, 0, 2488, 2491, + 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2492, + 1, 0, 0, 0, 2491, 2489, 1, 0, 0, 0, 2492, 2494, 5, 8, 0, 0, 2493, 2489, + 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2498, 1, 0, 0, 0, 2495, 2497, + 5, 5, 0, 0, 2496, 2495, 1, 0, 0, 0, 2497, 2500, 1, 0, 0, 0, 2498, 2496, + 1, 0, 0, 0, 2498, 2499, 1, 0, 0, 0, 2499, 2501, 1, 0, 0, 0, 2500, 2498, + 1, 0, 0, 0, 2501, 2502, 5, 47, 0, 0, 2502, 207, 1, 0, 0, 0, 2503, 2507, + 5, 9, 0, 0, 2504, 2506, 5, 5, 0, 0, 2505, 2504, 1, 0, 0, 0, 2506, 2509, + 1, 0, 0, 0, 2507, 2505, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2545, + 1, 0, 0, 0, 2509, 2507, 1, 0, 0, 0, 2510, 2527, 3, 210, 105, 0, 2511, 2513, + 5, 5, 0, 0, 2512, 2511, 1, 0, 0, 0, 2513, 2516, 1, 0, 0, 0, 2514, 2512, + 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, 2517, 1, 0, 0, 0, 2516, 2514, + 1, 0, 0, 0, 2517, 2521, 5, 8, 0, 0, 2518, 2520, 5, 5, 0, 0, 2519, 2518, + 1, 0, 0, 0, 2520, 2523, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2521, 2522, + 1, 0, 0, 0, 2522, 2524, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2524, 2526, + 3, 210, 105, 0, 2525, 2514, 1, 0, 0, 0, 2526, 2529, 1, 0, 0, 0, 2527, 2525, + 1, 0, 0, 0, 2527, 2528, 1, 0, 0, 0, 2528, 2537, 1, 0, 0, 0, 2529, 2527, + 1, 0, 0, 0, 2530, 2532, 5, 5, 0, 0, 2531, 2530, 1, 0, 0, 0, 2532, 2535, + 1, 0, 0, 0, 2533, 2531, 1, 0, 0, 0, 2533, 2534, 1, 0, 0, 0, 2534, 2536, + 1, 0, 0, 0, 2535, 2533, 1, 0, 0, 0, 2536, 2538, 5, 8, 0, 0, 2537, 2533, + 1, 0, 0, 0, 2537, 2538, 1, 0, 0, 0, 2538, 2542, 1, 0, 0, 0, 2539, 2541, + 5, 5, 0, 0, 2540, 2539, 1, 0, 0, 0, 2541, 2544, 1, 0, 0, 0, 2542, 2540, + 1, 0, 0, 0, 2542, 2543, 1, 0, 0, 0, 2543, 2546, 1, 0, 0, 0, 2544, 2542, + 1, 0, 0, 0, 2545, 2510, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2547, + 1, 0, 0, 0, 2547, 2548, 5, 10, 0, 0, 2548, 209, 1, 0, 0, 0, 2549, 2551, + 3, 334, 167, 0, 2550, 2549, 1, 0, 0, 0, 2550, 2551, 1, 0, 0, 0, 2551, 2555, + 1, 0, 0, 0, 2552, 2554, 5, 5, 0, 0, 2553, 2552, 1, 0, 0, 0, 2554, 2557, + 1, 0, 0, 0, 2555, 2553, 1, 0, 0, 0, 2555, 2556, 1, 0, 0, 0, 2556, 2572, + 1, 0, 0, 0, 2557, 2555, 1, 0, 0, 0, 2558, 2562, 3, 344, 172, 0, 2559, 2561, + 5, 5, 0, 0, 2560, 2559, 1, 0, 0, 0, 2561, 2564, 1, 0, 0, 0, 2562, 2560, + 1, 0, 0, 0, 2562, 2563, 1, 0, 0, 0, 2563, 2565, 1, 0, 0, 0, 2564, 2562, + 1, 0, 0, 0, 2565, 2569, 5, 28, 0, 0, 2566, 2568, 5, 5, 0, 0, 2567, 2566, + 1, 0, 0, 0, 2568, 2571, 1, 0, 0, 0, 2569, 2567, 1, 0, 0, 0, 2569, 2570, + 1, 0, 0, 0, 2570, 2573, 1, 0, 0, 0, 2571, 2569, 1, 0, 0, 0, 2572, 2558, + 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2575, 1, 0, 0, 0, 2574, 2576, + 5, 15, 0, 0, 2575, 2574, 1, 0, 0, 0, 2575, 2576, 1, 0, 0, 0, 2576, 2580, + 1, 0, 0, 0, 2577, 2579, 5, 5, 0, 0, 2578, 2577, 1, 0, 0, 0, 2579, 2582, + 1, 0, 0, 0, 2580, 2578, 1, 0, 0, 0, 2580, 2581, 1, 0, 0, 0, 2581, 2583, + 1, 0, 0, 0, 2582, 2580, 1, 0, 0, 0, 2583, 2584, 3, 152, 76, 0, 2584, 211, + 1, 0, 0, 0, 2585, 2600, 3, 214, 107, 0, 2586, 2600, 3, 344, 172, 0, 2587, + 2600, 3, 218, 109, 0, 2588, 2600, 3, 220, 110, 0, 2589, 2600, 3, 272, 136, + 0, 2590, 2600, 3, 242, 121, 0, 2591, 2600, 3, 244, 122, 0, 2592, 2600, + 3, 216, 108, 0, 2593, 2600, 3, 246, 123, 0, 2594, 2600, 3, 248, 124, 0, + 2595, 2600, 3, 250, 125, 0, 2596, 2600, 3, 254, 127, 0, 2597, 2600, 3, + 264, 132, 0, 2598, 2600, 3, 270, 135, 0, 2599, 2585, 1, 0, 0, 0, 2599, + 2586, 1, 0, 0, 0, 2599, 2587, 1, 0, 0, 0, 2599, 2588, 1, 0, 0, 0, 2599, + 2589, 1, 0, 0, 0, 2599, 2590, 1, 0, 0, 0, 2599, 2591, 1, 0, 0, 0, 2599, + 2592, 1, 0, 0, 0, 2599, 2593, 1, 0, 0, 0, 2599, 2594, 1, 0, 0, 0, 2599, + 2595, 1, 0, 0, 0, 2599, 2596, 1, 0, 0, 0, 2599, 2597, 1, 0, 0, 0, 2599, + 2598, 1, 0, 0, 0, 2600, 213, 1, 0, 0, 0, 2601, 2605, 5, 9, 0, 0, 2602, + 2604, 5, 5, 0, 0, 2603, 2602, 1, 0, 0, 0, 2604, 2607, 1, 0, 0, 0, 2605, + 2603, 1, 0, 0, 0, 2605, 2606, 1, 0, 0, 0, 2606, 2608, 1, 0, 0, 0, 2607, + 2605, 1, 0, 0, 0, 2608, 2612, 3, 152, 76, 0, 2609, 2611, 5, 5, 0, 0, 2610, + 2609, 1, 0, 0, 0, 2611, 2614, 1, 0, 0, 0, 2612, 2610, 1, 0, 0, 0, 2612, + 2613, 1, 0, 0, 0, 2613, 2615, 1, 0, 0, 0, 2614, 2612, 1, 0, 0, 0, 2615, + 2616, 5, 10, 0, 0, 2616, 215, 1, 0, 0, 0, 2617, 2621, 5, 11, 0, 0, 2618, + 2620, 5, 5, 0, 0, 2619, 2618, 1, 0, 0, 0, 2620, 2623, 1, 0, 0, 0, 2621, + 2619, 1, 0, 0, 0, 2621, 2622, 1, 0, 0, 0, 2622, 2659, 1, 0, 0, 0, 2623, + 2621, 1, 0, 0, 0, 2624, 2641, 3, 152, 76, 0, 2625, 2627, 5, 5, 0, 0, 2626, + 2625, 1, 0, 0, 0, 2627, 2630, 1, 0, 0, 0, 2628, 2626, 1, 0, 0, 0, 2628, + 2629, 1, 0, 0, 0, 2629, 2631, 1, 0, 0, 0, 2630, 2628, 1, 0, 0, 0, 2631, + 2635, 5, 8, 0, 0, 2632, 2634, 5, 5, 0, 0, 2633, 2632, 1, 0, 0, 0, 2634, + 2637, 1, 0, 0, 0, 2635, 2633, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, + 2638, 1, 0, 0, 0, 2637, 2635, 1, 0, 0, 0, 2638, 2640, 3, 152, 76, 0, 2639, + 2628, 1, 0, 0, 0, 2640, 2643, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2641, + 2642, 1, 0, 0, 0, 2642, 2651, 1, 0, 0, 0, 2643, 2641, 1, 0, 0, 0, 2644, + 2646, 5, 5, 0, 0, 2645, 2644, 1, 0, 0, 0, 2646, 2649, 1, 0, 0, 0, 2647, + 2645, 1, 0, 0, 0, 2647, 2648, 1, 0, 0, 0, 2648, 2650, 1, 0, 0, 0, 2649, + 2647, 1, 0, 0, 0, 2650, 2652, 5, 8, 0, 0, 2651, 2647, 1, 0, 0, 0, 2651, + 2652, 1, 0, 0, 0, 2652, 2656, 1, 0, 0, 0, 2653, 2655, 5, 5, 0, 0, 2654, + 2653, 1, 0, 0, 0, 2655, 2658, 1, 0, 0, 0, 2656, 2654, 1, 0, 0, 0, 2656, + 2657, 1, 0, 0, 0, 2657, 2660, 1, 0, 0, 0, 2658, 2656, 1, 0, 0, 0, 2659, + 2624, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2661, 1, 0, 0, 0, 2661, + 2662, 5, 12, 0, 0, 2662, 217, 1, 0, 0, 0, 2663, 2664, 7, 6, 0, 0, 2664, + 219, 1, 0, 0, 0, 2665, 2668, 3, 222, 111, 0, 2666, 2668, 3, 224, 112, 0, + 2667, 2665, 1, 0, 0, 0, 2667, 2666, 1, 0, 0, 0, 2668, 221, 1, 0, 0, 0, + 2669, 2674, 5, 150, 0, 0, 2670, 2673, 3, 226, 113, 0, 2671, 2673, 3, 228, + 114, 0, 2672, 2670, 1, 0, 0, 0, 2672, 2671, 1, 0, 0, 0, 2673, 2676, 1, + 0, 0, 0, 2674, 2672, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 2677, 1, + 0, 0, 0, 2676, 2674, 1, 0, 0, 0, 2677, 2678, 5, 159, 0, 0, 2678, 223, 1, + 0, 0, 0, 2679, 2685, 5, 151, 0, 0, 2680, 2684, 3, 230, 115, 0, 2681, 2684, + 3, 232, 116, 0, 2682, 2684, 5, 165, 0, 0, 2683, 2680, 1, 0, 0, 0, 2683, + 2681, 1, 0, 0, 0, 2683, 2682, 1, 0, 0, 0, 2684, 2687, 1, 0, 0, 0, 2685, + 2683, 1, 0, 0, 0, 2685, 2686, 1, 0, 0, 0, 2686, 2688, 1, 0, 0, 0, 2687, + 2685, 1, 0, 0, 0, 2688, 2689, 5, 164, 0, 0, 2689, 225, 1, 0, 0, 0, 2690, + 2691, 7, 7, 0, 0, 2691, 227, 1, 0, 0, 0, 2692, 2696, 5, 163, 0, 0, 2693, + 2695, 5, 5, 0, 0, 2694, 2693, 1, 0, 0, 0, 2695, 2698, 1, 0, 0, 0, 2696, + 2694, 1, 0, 0, 0, 2696, 2697, 1, 0, 0, 0, 2697, 2699, 1, 0, 0, 0, 2698, + 2696, 1, 0, 0, 0, 2699, 2703, 3, 152, 76, 0, 2700, 2702, 5, 5, 0, 0, 2701, + 2700, 1, 0, 0, 0, 2702, 2705, 1, 0, 0, 0, 2703, 2701, 1, 0, 0, 0, 2703, + 2704, 1, 0, 0, 0, 2704, 2706, 1, 0, 0, 0, 2705, 2703, 1, 0, 0, 0, 2706, + 2707, 5, 14, 0, 0, 2707, 229, 1, 0, 0, 0, 2708, 2709, 7, 8, 0, 0, 2709, + 231, 1, 0, 0, 0, 2710, 2714, 5, 168, 0, 0, 2711, 2713, 5, 5, 0, 0, 2712, + 2711, 1, 0, 0, 0, 2713, 2716, 1, 0, 0, 0, 2714, 2712, 1, 0, 0, 0, 2714, + 2715, 1, 0, 0, 0, 2715, 2717, 1, 0, 0, 0, 2716, 2714, 1, 0, 0, 0, 2717, + 2721, 3, 152, 76, 0, 2718, 2720, 5, 5, 0, 0, 2719, 2718, 1, 0, 0, 0, 2720, + 2723, 1, 0, 0, 0, 2721, 2719, 1, 0, 0, 0, 2721, 2722, 1, 0, 0, 0, 2722, + 2724, 1, 0, 0, 0, 2723, 2721, 1, 0, 0, 0, 2724, 2725, 5, 14, 0, 0, 2725, + 233, 1, 0, 0, 0, 2726, 2730, 5, 13, 0, 0, 2727, 2729, 5, 5, 0, 0, 2728, + 2727, 1, 0, 0, 0, 2729, 2732, 1, 0, 0, 0, 2730, 2728, 1, 0, 0, 0, 2730, + 2731, 1, 0, 0, 0, 2731, 2749, 1, 0, 0, 0, 2732, 2730, 1, 0, 0, 0, 2733, + 2735, 3, 236, 118, 0, 2734, 2733, 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, + 2739, 1, 0, 0, 0, 2736, 2738, 5, 5, 0, 0, 2737, 2736, 1, 0, 0, 0, 2738, + 2741, 1, 0, 0, 0, 2739, 2737, 1, 0, 0, 0, 2739, 2740, 1, 0, 0, 0, 2740, + 2742, 1, 0, 0, 0, 2741, 2739, 1, 0, 0, 0, 2742, 2746, 5, 34, 0, 0, 2743, + 2745, 5, 5, 0, 0, 2744, 2743, 1, 0, 0, 0, 2745, 2748, 1, 0, 0, 0, 2746, + 2744, 1, 0, 0, 0, 2746, 2747, 1, 0, 0, 0, 2747, 2750, 1, 0, 0, 0, 2748, + 2746, 1, 0, 0, 0, 2749, 2734, 1, 0, 0, 0, 2749, 2750, 1, 0, 0, 0, 2750, + 2751, 1, 0, 0, 0, 2751, 2755, 3, 128, 64, 0, 2752, 2754, 5, 5, 0, 0, 2753, + 2752, 1, 0, 0, 0, 2754, 2757, 1, 0, 0, 0, 2755, 2753, 1, 0, 0, 0, 2755, + 2756, 1, 0, 0, 0, 2756, 2758, 1, 0, 0, 0, 2757, 2755, 1, 0, 0, 0, 2758, + 2759, 5, 14, 0, 0, 2759, 235, 1, 0, 0, 0, 2760, 2777, 3, 238, 119, 0, 2761, + 2763, 5, 5, 0, 0, 2762, 2761, 1, 0, 0, 0, 2763, 2766, 1, 0, 0, 0, 2764, + 2762, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 2767, 1, 0, 0, 0, 2766, + 2764, 1, 0, 0, 0, 2767, 2771, 5, 8, 0, 0, 2768, 2770, 5, 5, 0, 0, 2769, + 2768, 1, 0, 0, 0, 2770, 2773, 1, 0, 0, 0, 2771, 2769, 1, 0, 0, 0, 2771, + 2772, 1, 0, 0, 0, 2772, 2774, 1, 0, 0, 0, 2773, 2771, 1, 0, 0, 0, 2774, + 2776, 3, 238, 119, 0, 2775, 2764, 1, 0, 0, 0, 2776, 2779, 1, 0, 0, 0, 2777, + 2775, 1, 0, 0, 0, 2777, 2778, 1, 0, 0, 0, 2778, 2787, 1, 0, 0, 0, 2779, + 2777, 1, 0, 0, 0, 2780, 2782, 5, 5, 0, 0, 2781, 2780, 1, 0, 0, 0, 2782, + 2785, 1, 0, 0, 0, 2783, 2781, 1, 0, 0, 0, 2783, 2784, 1, 0, 0, 0, 2784, + 2786, 1, 0, 0, 0, 2785, 2783, 1, 0, 0, 0, 2786, 2788, 5, 8, 0, 0, 2787, + 2783, 1, 0, 0, 0, 2787, 2788, 1, 0, 0, 0, 2788, 237, 1, 0, 0, 0, 2789, + 2808, 3, 66, 33, 0, 2790, 2805, 3, 68, 34, 0, 2791, 2793, 5, 5, 0, 0, 2792, + 2791, 1, 0, 0, 0, 2793, 2796, 1, 0, 0, 0, 2794, 2792, 1, 0, 0, 0, 2794, + 2795, 1, 0, 0, 0, 2795, 2797, 1, 0, 0, 0, 2796, 2794, 1, 0, 0, 0, 2797, + 2801, 5, 26, 0, 0, 2798, 2800, 5, 5, 0, 0, 2799, 2798, 1, 0, 0, 0, 2800, + 2803, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2801, 2802, 1, 0, 0, 0, 2802, + 2804, 1, 0, 0, 0, 2803, 2801, 1, 0, 0, 0, 2804, 2806, 3, 98, 49, 0, 2805, + 2794, 1, 0, 0, 0, 2805, 2806, 1, 0, 0, 0, 2806, 2808, 1, 0, 0, 0, 2807, + 2789, 1, 0, 0, 0, 2807, 2790, 1, 0, 0, 0, 2808, 239, 1, 0, 0, 0, 2809, + 2825, 5, 75, 0, 0, 2810, 2812, 5, 5, 0, 0, 2811, 2810, 1, 0, 0, 0, 2812, + 2815, 1, 0, 0, 0, 2813, 2811, 1, 0, 0, 0, 2813, 2814, 1, 0, 0, 0, 2814, + 2816, 1, 0, 0, 0, 2815, 2813, 1, 0, 0, 0, 2816, 2820, 3, 98, 49, 0, 2817, + 2819, 5, 5, 0, 0, 2818, 2817, 1, 0, 0, 0, 2819, 2822, 1, 0, 0, 0, 2820, + 2818, 1, 0, 0, 0, 2820, 2821, 1, 0, 0, 0, 2821, 2823, 1, 0, 0, 0, 2822, + 2820, 1, 0, 0, 0, 2823, 2824, 5, 7, 0, 0, 2824, 2826, 1, 0, 0, 0, 2825, + 2813, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2830, 1, 0, 0, 0, 2827, + 2829, 5, 5, 0, 0, 2828, 2827, 1, 0, 0, 0, 2829, 2832, 1, 0, 0, 0, 2830, + 2828, 1, 0, 0, 0, 2830, 2831, 1, 0, 0, 0, 2831, 2833, 1, 0, 0, 0, 2832, + 2830, 1, 0, 0, 0, 2833, 2848, 3, 78, 39, 0, 2834, 2836, 5, 5, 0, 0, 2835, + 2834, 1, 0, 0, 0, 2836, 2839, 1, 0, 0, 0, 2837, 2835, 1, 0, 0, 0, 2837, + 2838, 1, 0, 0, 0, 2838, 2840, 1, 0, 0, 0, 2839, 2837, 1, 0, 0, 0, 2840, + 2844, 5, 26, 0, 0, 2841, 2843, 5, 5, 0, 0, 2842, 2841, 1, 0, 0, 0, 2843, + 2846, 1, 0, 0, 0, 2844, 2842, 1, 0, 0, 0, 2844, 2845, 1, 0, 0, 0, 2845, + 2847, 1, 0, 0, 0, 2846, 2844, 1, 0, 0, 0, 2847, 2849, 3, 98, 49, 0, 2848, + 2837, 1, 0, 0, 0, 2848, 2849, 1, 0, 0, 0, 2849, 2857, 1, 0, 0, 0, 2850, + 2852, 5, 5, 0, 0, 2851, 2850, 1, 0, 0, 0, 2852, 2855, 1, 0, 0, 0, 2853, + 2851, 1, 0, 0, 0, 2853, 2854, 1, 0, 0, 0, 2854, 2856, 1, 0, 0, 0, 2855, + 2853, 1, 0, 0, 0, 2856, 2858, 3, 46, 23, 0, 2857, 2853, 1, 0, 0, 0, 2857, + 2858, 1, 0, 0, 0, 2858, 2866, 1, 0, 0, 0, 2859, 2861, 5, 5, 0, 0, 2860, + 2859, 1, 0, 0, 0, 2861, 2864, 1, 0, 0, 0, 2862, 2860, 1, 0, 0, 0, 2862, + 2863, 1, 0, 0, 0, 2863, 2865, 1, 0, 0, 0, 2864, 2862, 1, 0, 0, 0, 2865, + 2867, 3, 64, 32, 0, 2866, 2862, 1, 0, 0, 0, 2866, 2867, 1, 0, 0, 0, 2867, + 241, 1, 0, 0, 0, 2868, 2871, 3, 234, 117, 0, 2869, 2871, 3, 240, 120, 0, + 2870, 2868, 1, 0, 0, 0, 2870, 2869, 1, 0, 0, 0, 2871, 243, 1, 0, 0, 0, + 2872, 2893, 5, 76, 0, 0, 2873, 2875, 5, 5, 0, 0, 2874, 2873, 1, 0, 0, 0, + 2875, 2878, 1, 0, 0, 0, 2876, 2874, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, + 2877, 2879, 1, 0, 0, 0, 2878, 2876, 1, 0, 0, 0, 2879, 2883, 5, 26, 0, 0, + 2880, 2882, 5, 5, 0, 0, 2881, 2880, 1, 0, 0, 0, 2882, 2885, 1, 0, 0, 0, + 2883, 2881, 1, 0, 0, 0, 2883, 2884, 1, 0, 0, 0, 2884, 2886, 1, 0, 0, 0, + 2885, 2883, 1, 0, 0, 0, 2886, 2890, 3, 32, 16, 0, 2887, 2889, 5, 5, 0, + 0, 2888, 2887, 1, 0, 0, 0, 2889, 2892, 1, 0, 0, 0, 2890, 2888, 1, 0, 0, + 0, 2890, 2891, 1, 0, 0, 0, 2891, 2894, 1, 0, 0, 0, 2892, 2890, 1, 0, 0, + 0, 2893, 2876, 1, 0, 0, 0, 2893, 2894, 1, 0, 0, 0, 2894, 2902, 1, 0, 0, + 0, 2895, 2897, 5, 5, 0, 0, 2896, 2895, 1, 0, 0, 0, 2897, 2900, 1, 0, 0, + 0, 2898, 2896, 1, 0, 0, 0, 2898, 2899, 1, 0, 0, 0, 2899, 2901, 1, 0, 0, + 0, 2900, 2898, 1, 0, 0, 0, 2901, 2903, 3, 26, 13, 0, 2902, 2898, 1, 0, + 0, 0, 2902, 2903, 1, 0, 0, 0, 2903, 245, 1, 0, 0, 0, 2904, 2905, 7, 9, + 0, 0, 2905, 247, 1, 0, 0, 0, 2906, 2923, 5, 85, 0, 0, 2907, 2911, 5, 46, + 0, 0, 2908, 2910, 5, 5, 0, 0, 2909, 2908, 1, 0, 0, 0, 2910, 2913, 1, 0, + 0, 0, 2911, 2909, 1, 0, 0, 0, 2911, 2912, 1, 0, 0, 0, 2912, 2914, 1, 0, + 0, 0, 2913, 2911, 1, 0, 0, 0, 2914, 2918, 3, 98, 49, 0, 2915, 2917, 5, + 5, 0, 0, 2916, 2915, 1, 0, 0, 0, 2917, 2920, 1, 0, 0, 0, 2918, 2916, 1, + 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 2921, 1, 0, 0, 0, 2920, 2918, 1, + 0, 0, 0, 2921, 2922, 5, 47, 0, 0, 2922, 2924, 1, 0, 0, 0, 2923, 2907, 1, + 0, 0, 0, 2923, 2924, 1, 0, 0, 0, 2924, 2927, 1, 0, 0, 0, 2925, 2926, 5, + 40, 0, 0, 2926, 2928, 3, 344, 172, 0, 2927, 2925, 1, 0, 0, 0, 2927, 2928, + 1, 0, 0, 0, 2928, 2931, 1, 0, 0, 0, 2929, 2931, 5, 61, 0, 0, 2930, 2906, + 1, 0, 0, 0, 2930, 2929, 1, 0, 0, 0, 2931, 249, 1, 0, 0, 0, 2932, 2936, + 5, 88, 0, 0, 2933, 2935, 5, 5, 0, 0, 2934, 2933, 1, 0, 0, 0, 2935, 2938, + 1, 0, 0, 0, 2936, 2934, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 2939, + 1, 0, 0, 0, 2938, 2936, 1, 0, 0, 0, 2939, 2943, 5, 9, 0, 0, 2940, 2942, + 5, 5, 0, 0, 2941, 2940, 1, 0, 0, 0, 2942, 2945, 1, 0, 0, 0, 2943, 2941, + 1, 0, 0, 0, 2943, 2944, 1, 0, 0, 0, 2944, 2946, 1, 0, 0, 0, 2945, 2943, + 1, 0, 0, 0, 2946, 2950, 3, 152, 76, 0, 2947, 2949, 5, 5, 0, 0, 2948, 2947, + 1, 0, 0, 0, 2949, 2952, 1, 0, 0, 0, 2950, 2948, 1, 0, 0, 0, 2950, 2951, + 1, 0, 0, 0, 2951, 2953, 1, 0, 0, 0, 2952, 2950, 1, 0, 0, 0, 2953, 2957, + 5, 10, 0, 0, 2954, 2956, 5, 5, 0, 0, 2955, 2954, 1, 0, 0, 0, 2956, 2959, + 1, 0, 0, 0, 2957, 2955, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, 2991, + 1, 0, 0, 0, 2959, 2957, 1, 0, 0, 0, 2960, 2992, 3, 134, 67, 0, 2961, 2963, + 3, 134, 67, 0, 2962, 2961, 1, 0, 0, 0, 2962, 2963, 1, 0, 0, 0, 2963, 2967, + 1, 0, 0, 0, 2964, 2966, 5, 5, 0, 0, 2965, 2964, 1, 0, 0, 0, 2966, 2969, + 1, 0, 0, 0, 2967, 2965, 1, 0, 0, 0, 2967, 2968, 1, 0, 0, 0, 2968, 2971, + 1, 0, 0, 0, 2969, 2967, 1, 0, 0, 0, 2970, 2972, 5, 27, 0, 0, 2971, 2970, + 1, 0, 0, 0, 2971, 2972, 1, 0, 0, 0, 2972, 2976, 1, 0, 0, 0, 2973, 2975, + 5, 5, 0, 0, 2974, 2973, 1, 0, 0, 0, 2975, 2978, 1, 0, 0, 0, 2976, 2974, + 1, 0, 0, 0, 2976, 2977, 1, 0, 0, 0, 2977, 2979, 1, 0, 0, 0, 2978, 2976, + 1, 0, 0, 0, 2979, 2983, 5, 89, 0, 0, 2980, 2982, 5, 5, 0, 0, 2981, 2980, + 1, 0, 0, 0, 2982, 2985, 1, 0, 0, 0, 2983, 2981, 1, 0, 0, 0, 2983, 2984, + 1, 0, 0, 0, 2984, 2988, 1, 0, 0, 0, 2985, 2983, 1, 0, 0, 0, 2986, 2989, + 3, 134, 67, 0, 2987, 2989, 5, 27, 0, 0, 2988, 2986, 1, 0, 0, 0, 2988, 2987, + 1, 0, 0, 0, 2989, 2992, 1, 0, 0, 0, 2990, 2992, 5, 27, 0, 0, 2991, 2960, + 1, 0, 0, 0, 2991, 2962, 1, 0, 0, 0, 2991, 2990, 1, 0, 0, 0, 2992, 251, + 1, 0, 0, 0, 2993, 3027, 5, 9, 0, 0, 2994, 2996, 3, 334, 167, 0, 2995, 2994, + 1, 0, 0, 0, 2996, 2999, 1, 0, 0, 0, 2997, 2995, 1, 0, 0, 0, 2997, 2998, + 1, 0, 0, 0, 2998, 3003, 1, 0, 0, 0, 2999, 2997, 1, 0, 0, 0, 3000, 3002, + 5, 5, 0, 0, 3001, 3000, 1, 0, 0, 0, 3002, 3005, 1, 0, 0, 0, 3003, 3001, + 1, 0, 0, 0, 3003, 3004, 1, 0, 0, 0, 3004, 3006, 1, 0, 0, 0, 3005, 3003, + 1, 0, 0, 0, 3006, 3010, 5, 77, 0, 0, 3007, 3009, 5, 5, 0, 0, 3008, 3007, + 1, 0, 0, 0, 3009, 3012, 1, 0, 0, 0, 3010, 3008, 1, 0, 0, 0, 3010, 3011, + 1, 0, 0, 0, 3011, 3013, 1, 0, 0, 0, 3012, 3010, 1, 0, 0, 0, 3013, 3017, + 3, 66, 33, 0, 3014, 3016, 5, 5, 0, 0, 3015, 3014, 1, 0, 0, 0, 3016, 3019, + 1, 0, 0, 0, 3017, 3015, 1, 0, 0, 0, 3017, 3018, 1, 0, 0, 0, 3018, 3020, + 1, 0, 0, 0, 3019, 3017, 1, 0, 0, 0, 3020, 3024, 5, 28, 0, 0, 3021, 3023, + 5, 5, 0, 0, 3022, 3021, 1, 0, 0, 0, 3023, 3026, 1, 0, 0, 0, 3024, 3022, + 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3028, 1, 0, 0, 0, 3026, 3024, + 1, 0, 0, 0, 3027, 2997, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 3029, + 1, 0, 0, 0, 3029, 3030, 3, 152, 76, 0, 3030, 3031, 5, 10, 0, 0, 3031, 253, + 1, 0, 0, 0, 3032, 3036, 5, 90, 0, 0, 3033, 3035, 5, 5, 0, 0, 3034, 3033, + 1, 0, 0, 0, 3035, 3038, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, + 1, 0, 0, 0, 3037, 3040, 1, 0, 0, 0, 3038, 3036, 1, 0, 0, 0, 3039, 3041, + 3, 252, 126, 0, 3040, 3039, 1, 0, 0, 0, 3040, 3041, 1, 0, 0, 0, 3041, 3045, + 1, 0, 0, 0, 3042, 3044, 5, 5, 0, 0, 3043, 3042, 1, 0, 0, 0, 3044, 3047, + 1, 0, 0, 0, 3045, 3043, 1, 0, 0, 0, 3045, 3046, 1, 0, 0, 0, 3046, 3048, + 1, 0, 0, 0, 3047, 3045, 1, 0, 0, 0, 3048, 3052, 5, 13, 0, 0, 3049, 3051, + 5, 5, 0, 0, 3050, 3049, 1, 0, 0, 0, 3051, 3054, 1, 0, 0, 0, 3052, 3050, + 1, 0, 0, 0, 3052, 3053, 1, 0, 0, 0, 3053, 3064, 1, 0, 0, 0, 3054, 3052, + 1, 0, 0, 0, 3055, 3059, 3, 256, 128, 0, 3056, 3058, 5, 5, 0, 0, 3057, 3056, + 1, 0, 0, 0, 3058, 3061, 1, 0, 0, 0, 3059, 3057, 1, 0, 0, 0, 3059, 3060, + 1, 0, 0, 0, 3060, 3063, 1, 0, 0, 0, 3061, 3059, 1, 0, 0, 0, 3062, 3055, + 1, 0, 0, 0, 3063, 3066, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3064, 3065, + 1, 0, 0, 0, 3065, 3070, 1, 0, 0, 0, 3066, 3064, 1, 0, 0, 0, 3067, 3069, + 5, 5, 0, 0, 3068, 3067, 1, 0, 0, 0, 3069, 3072, 1, 0, 0, 0, 3070, 3068, + 1, 0, 0, 0, 3070, 3071, 1, 0, 0, 0, 3071, 3073, 1, 0, 0, 0, 3072, 3070, + 1, 0, 0, 0, 3073, 3074, 5, 14, 0, 0, 3074, 255, 1, 0, 0, 0, 3075, 3092, + 3, 258, 129, 0, 3076, 3078, 5, 5, 0, 0, 3077, 3076, 1, 0, 0, 0, 3078, 3081, + 1, 0, 0, 0, 3079, 3077, 1, 0, 0, 0, 3079, 3080, 1, 0, 0, 0, 3080, 3082, + 1, 0, 0, 0, 3081, 3079, 1, 0, 0, 0, 3082, 3086, 5, 8, 0, 0, 3083, 3085, + 5, 5, 0, 0, 3084, 3083, 1, 0, 0, 0, 3085, 3088, 1, 0, 0, 0, 3086, 3084, + 1, 0, 0, 0, 3086, 3087, 1, 0, 0, 0, 3087, 3089, 1, 0, 0, 0, 3088, 3086, + 1, 0, 0, 0, 3089, 3091, 3, 258, 129, 0, 3090, 3079, 1, 0, 0, 0, 3091, 3094, + 1, 0, 0, 0, 3092, 3090, 1, 0, 0, 0, 3092, 3093, 1, 0, 0, 0, 3093, 3102, + 1, 0, 0, 0, 3094, 3092, 1, 0, 0, 0, 3095, 3097, 5, 5, 0, 0, 3096, 3095, + 1, 0, 0, 0, 3097, 3100, 1, 0, 0, 0, 3098, 3096, 1, 0, 0, 0, 3098, 3099, + 1, 0, 0, 0, 3099, 3101, 1, 0, 0, 0, 3100, 3098, 1, 0, 0, 0, 3101, 3103, + 5, 8, 0, 0, 3102, 3098, 1, 0, 0, 0, 3102, 3103, 1, 0, 0, 0, 3103, 3107, + 1, 0, 0, 0, 3104, 3106, 5, 5, 0, 0, 3105, 3104, 1, 0, 0, 0, 3106, 3109, + 1, 0, 0, 0, 3107, 3105, 1, 0, 0, 0, 3107, 3108, 1, 0, 0, 0, 3108, 3110, + 1, 0, 0, 0, 3109, 3107, 1, 0, 0, 0, 3110, 3114, 5, 34, 0, 0, 3111, 3113, + 5, 5, 0, 0, 3112, 3111, 1, 0, 0, 0, 3113, 3116, 1, 0, 0, 0, 3114, 3112, + 1, 0, 0, 0, 3114, 3115, 1, 0, 0, 0, 3115, 3117, 1, 0, 0, 0, 3116, 3114, + 1, 0, 0, 0, 3117, 3119, 3, 134, 67, 0, 3118, 3120, 3, 148, 74, 0, 3119, + 3118, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 3140, 1, 0, 0, 0, 3121, + 3125, 5, 89, 0, 0, 3122, 3124, 5, 5, 0, 0, 3123, 3122, 1, 0, 0, 0, 3124, + 3127, 1, 0, 0, 0, 3125, 3123, 1, 0, 0, 0, 3125, 3126, 1, 0, 0, 0, 3126, + 3128, 1, 0, 0, 0, 3127, 3125, 1, 0, 0, 0, 3128, 3132, 5, 34, 0, 0, 3129, + 3131, 5, 5, 0, 0, 3130, 3129, 1, 0, 0, 0, 3131, 3134, 1, 0, 0, 0, 3132, + 3130, 1, 0, 0, 0, 3132, 3133, 1, 0, 0, 0, 3133, 3135, 1, 0, 0, 0, 3134, + 3132, 1, 0, 0, 0, 3135, 3137, 3, 134, 67, 0, 3136, 3138, 3, 148, 74, 0, + 3137, 3136, 1, 0, 0, 0, 3137, 3138, 1, 0, 0, 0, 3138, 3140, 1, 0, 0, 0, + 3139, 3075, 1, 0, 0, 0, 3139, 3121, 1, 0, 0, 0, 3140, 257, 1, 0, 0, 0, + 3141, 3145, 3, 152, 76, 0, 3142, 3145, 3, 260, 130, 0, 3143, 3145, 3, 262, + 131, 0, 3144, 3141, 1, 0, 0, 0, 3144, 3142, 1, 0, 0, 0, 3144, 3143, 1, + 0, 0, 0, 3145, 259, 1, 0, 0, 0, 3146, 3150, 3, 280, 140, 0, 3147, 3149, + 5, 5, 0, 0, 3148, 3147, 1, 0, 0, 0, 3149, 3152, 1, 0, 0, 0, 3150, 3148, + 1, 0, 0, 0, 3150, 3151, 1, 0, 0, 0, 3151, 3153, 1, 0, 0, 0, 3152, 3150, + 1, 0, 0, 0, 3153, 3154, 3, 152, 76, 0, 3154, 261, 1, 0, 0, 0, 3155, 3159, + 3, 282, 141, 0, 3156, 3158, 5, 5, 0, 0, 3157, 3156, 1, 0, 0, 0, 3158, 3161, + 1, 0, 0, 0, 3159, 3157, 1, 0, 0, 0, 3159, 3160, 1, 0, 0, 0, 3160, 3162, + 1, 0, 0, 0, 3161, 3159, 1, 0, 0, 0, 3162, 3163, 3, 98, 49, 0, 3163, 263, + 1, 0, 0, 0, 3164, 3168, 5, 91, 0, 0, 3165, 3167, 5, 5, 0, 0, 3166, 3165, + 1, 0, 0, 0, 3167, 3170, 1, 0, 0, 0, 3168, 3166, 1, 0, 0, 0, 3168, 3169, + 1, 0, 0, 0, 3169, 3171, 1, 0, 0, 0, 3170, 3168, 1, 0, 0, 0, 3171, 3199, + 3, 136, 68, 0, 3172, 3174, 5, 5, 0, 0, 3173, 3172, 1, 0, 0, 0, 3174, 3177, + 1, 0, 0, 0, 3175, 3173, 1, 0, 0, 0, 3175, 3176, 1, 0, 0, 0, 3176, 3178, + 1, 0, 0, 0, 3177, 3175, 1, 0, 0, 0, 3178, 3180, 3, 266, 133, 0, 3179, 3175, + 1, 0, 0, 0, 3180, 3181, 1, 0, 0, 0, 3181, 3179, 1, 0, 0, 0, 3181, 3182, + 1, 0, 0, 0, 3182, 3190, 1, 0, 0, 0, 3183, 3185, 5, 5, 0, 0, 3184, 3183, + 1, 0, 0, 0, 3185, 3188, 1, 0, 0, 0, 3186, 3184, 1, 0, 0, 0, 3186, 3187, + 1, 0, 0, 0, 3187, 3189, 1, 0, 0, 0, 3188, 3186, 1, 0, 0, 0, 3189, 3191, + 3, 268, 134, 0, 3190, 3186, 1, 0, 0, 0, 3190, 3191, 1, 0, 0, 0, 3191, 3200, + 1, 0, 0, 0, 3192, 3194, 5, 5, 0, 0, 3193, 3192, 1, 0, 0, 0, 3194, 3197, + 1, 0, 0, 0, 3195, 3193, 1, 0, 0, 0, 3195, 3196, 1, 0, 0, 0, 3196, 3198, + 1, 0, 0, 0, 3197, 3195, 1, 0, 0, 0, 3198, 3200, 3, 268, 134, 0, 3199, 3179, + 1, 0, 0, 0, 3199, 3195, 1, 0, 0, 0, 3200, 265, 1, 0, 0, 0, 3201, 3205, + 5, 92, 0, 0, 3202, 3204, 5, 5, 0, 0, 3203, 3202, 1, 0, 0, 0, 3204, 3207, + 1, 0, 0, 0, 3205, 3203, 1, 0, 0, 0, 3205, 3206, 1, 0, 0, 0, 3206, 3208, + 1, 0, 0, 0, 3207, 3205, 1, 0, 0, 0, 3208, 3212, 5, 9, 0, 0, 3209, 3211, + 3, 334, 167, 0, 3210, 3209, 1, 0, 0, 0, 3211, 3214, 1, 0, 0, 0, 3212, 3210, + 1, 0, 0, 0, 3212, 3213, 1, 0, 0, 0, 3213, 3215, 1, 0, 0, 0, 3214, 3212, + 1, 0, 0, 0, 3215, 3216, 3, 344, 172, 0, 3216, 3217, 5, 26, 0, 0, 3217, + 3225, 3, 98, 49, 0, 3218, 3220, 5, 5, 0, 0, 3219, 3218, 1, 0, 0, 0, 3220, + 3223, 1, 0, 0, 0, 3221, 3219, 1, 0, 0, 0, 3221, 3222, 1, 0, 0, 0, 3222, + 3224, 1, 0, 0, 0, 3223, 3221, 1, 0, 0, 0, 3224, 3226, 5, 8, 0, 0, 3225, + 3221, 1, 0, 0, 0, 3225, 3226, 1, 0, 0, 0, 3226, 3227, 1, 0, 0, 0, 3227, + 3231, 5, 10, 0, 0, 3228, 3230, 5, 5, 0, 0, 3229, 3228, 1, 0, 0, 0, 3230, + 3233, 1, 0, 0, 0, 3231, 3229, 1, 0, 0, 0, 3231, 3232, 1, 0, 0, 0, 3232, + 3234, 1, 0, 0, 0, 3233, 3231, 1, 0, 0, 0, 3234, 3235, 3, 136, 68, 0, 3235, + 267, 1, 0, 0, 0, 3236, 3240, 5, 93, 0, 0, 3237, 3239, 5, 5, 0, 0, 3238, + 3237, 1, 0, 0, 0, 3239, 3242, 1, 0, 0, 0, 3240, 3238, 1, 0, 0, 0, 3240, + 3241, 1, 0, 0, 0, 3241, 3243, 1, 0, 0, 0, 3242, 3240, 1, 0, 0, 0, 3243, + 3244, 3, 136, 68, 0, 3244, 269, 1, 0, 0, 0, 3245, 3249, 5, 97, 0, 0, 3246, + 3248, 5, 5, 0, 0, 3247, 3246, 1, 0, 0, 0, 3248, 3251, 1, 0, 0, 0, 3249, + 3247, 1, 0, 0, 0, 3249, 3250, 1, 0, 0, 0, 3250, 3252, 1, 0, 0, 0, 3251, + 3249, 1, 0, 0, 0, 3252, 3262, 3, 152, 76, 0, 3253, 3255, 7, 10, 0, 0, 3254, + 3256, 3, 152, 76, 0, 3255, 3254, 1, 0, 0, 0, 3255, 3256, 1, 0, 0, 0, 3256, + 3262, 1, 0, 0, 0, 3257, 3262, 5, 99, 0, 0, 3258, 3262, 5, 58, 0, 0, 3259, + 3262, 5, 100, 0, 0, 3260, 3262, 5, 59, 0, 0, 3261, 3245, 1, 0, 0, 0, 3261, + 3253, 1, 0, 0, 0, 3261, 3257, 1, 0, 0, 0, 3261, 3258, 1, 0, 0, 0, 3261, + 3259, 1, 0, 0, 0, 3261, 3260, 1, 0, 0, 0, 3262, 271, 1, 0, 0, 0, 3263, + 3265, 3, 122, 61, 0, 3264, 3263, 1, 0, 0, 0, 3264, 3265, 1, 0, 0, 0, 3265, + 3266, 1, 0, 0, 0, 3266, 3270, 5, 37, 0, 0, 3267, 3269, 5, 5, 0, 0, 3268, + 3267, 1, 0, 0, 0, 3269, 3272, 1, 0, 0, 0, 3270, 3268, 1, 0, 0, 0, 3270, + 3271, 1, 0, 0, 0, 3271, 3275, 1, 0, 0, 0, 3272, 3270, 1, 0, 0, 0, 3273, + 3276, 3, 344, 172, 0, 3274, 3276, 5, 73, 0, 0, 3275, 3273, 1, 0, 0, 0, + 3275, 3274, 1, 0, 0, 0, 3276, 273, 1, 0, 0, 0, 3277, 3278, 7, 11, 0, 0, + 3278, 275, 1, 0, 0, 0, 3279, 3280, 7, 12, 0, 0, 3280, 277, 1, 0, 0, 0, + 3281, 3282, 7, 13, 0, 0, 3282, 279, 1, 0, 0, 0, 3283, 3284, 7, 14, 0, 0, + 3284, 281, 1, 0, 0, 0, 3285, 3286, 7, 15, 0, 0, 3286, 283, 1, 0, 0, 0, + 3287, 3288, 7, 16, 0, 0, 3288, 285, 1, 0, 0, 0, 3289, 3290, 7, 17, 0, 0, + 3290, 287, 1, 0, 0, 0, 3291, 3292, 7, 18, 0, 0, 3292, 289, 1, 0, 0, 0, + 3293, 3299, 5, 20, 0, 0, 3294, 3299, 5, 21, 0, 0, 3295, 3299, 5, 19, 0, + 0, 3296, 3299, 5, 18, 0, 0, 3297, 3299, 3, 294, 147, 0, 3298, 3293, 1, + 0, 0, 0, 3298, 3294, 1, 0, 0, 0, 3298, 3295, 1, 0, 0, 0, 3298, 3296, 1, + 0, 0, 0, 3298, 3297, 1, 0, 0, 0, 3299, 291, 1, 0, 0, 0, 3300, 3305, 5, + 20, 0, 0, 3301, 3305, 5, 21, 0, 0, 3302, 3303, 5, 25, 0, 0, 3303, 3305, + 3, 294, 147, 0, 3304, 3300, 1, 0, 0, 0, 3304, 3301, 1, 0, 0, 0, 3304, 3302, + 1, 0, 0, 0, 3305, 293, 1, 0, 0, 0, 3306, 3307, 7, 19, 0, 0, 3307, 295, + 1, 0, 0, 0, 3308, 3310, 5, 5, 0, 0, 3309, 3308, 1, 0, 0, 0, 3310, 3313, + 1, 0, 0, 0, 3311, 3309, 1, 0, 0, 0, 3311, 3312, 1, 0, 0, 0, 3312, 3314, + 1, 0, 0, 0, 3313, 3311, 1, 0, 0, 0, 3314, 3324, 5, 7, 0, 0, 3315, 3317, + 5, 5, 0, 0, 3316, 3315, 1, 0, 0, 0, 3317, 3320, 1, 0, 0, 0, 3318, 3316, + 1, 0, 0, 0, 3318, 3319, 1, 0, 0, 0, 3319, 3321, 1, 0, 0, 0, 3320, 3318, + 1, 0, 0, 0, 3321, 3324, 3, 298, 149, 0, 3322, 3324, 5, 37, 0, 0, 3323, + 3311, 1, 0, 0, 0, 3323, 3318, 1, 0, 0, 0, 3323, 3322, 1, 0, 0, 0, 3324, + 297, 1, 0, 0, 0, 3325, 3326, 5, 45, 0, 0, 3326, 3327, 5, 7, 0, 0, 3327, + 299, 1, 0, 0, 0, 3328, 3331, 3, 334, 167, 0, 3329, 3331, 3, 304, 152, 0, + 3330, 3328, 1, 0, 0, 0, 3330, 3329, 1, 0, 0, 0, 3331, 3332, 1, 0, 0, 0, + 3332, 3330, 1, 0, 0, 0, 3332, 3333, 1, 0, 0, 0, 3333, 301, 1, 0, 0, 0, + 3334, 3337, 3, 334, 167, 0, 3335, 3337, 3, 328, 164, 0, 3336, 3334, 1, + 0, 0, 0, 3336, 3335, 1, 0, 0, 0, 3337, 3338, 1, 0, 0, 0, 3338, 3336, 1, + 0, 0, 0, 3338, 3339, 1, 0, 0, 0, 3339, 303, 1, 0, 0, 0, 3340, 3349, 3, + 310, 155, 0, 3341, 3349, 3, 312, 156, 0, 3342, 3349, 3, 314, 157, 0, 3343, + 3349, 3, 322, 161, 0, 3344, 3349, 3, 324, 162, 0, 3345, 3349, 3, 326, 163, + 0, 3346, 3349, 3, 328, 164, 0, 3347, 3349, 3, 332, 166, 0, 3348, 3340, + 1, 0, 0, 0, 3348, 3341, 1, 0, 0, 0, 3348, 3342, 1, 0, 0, 0, 3348, 3343, + 1, 0, 0, 0, 3348, 3344, 1, 0, 0, 0, 3348, 3345, 1, 0, 0, 0, 3348, 3346, + 1, 0, 0, 0, 3348, 3347, 1, 0, 0, 0, 3349, 3353, 1, 0, 0, 0, 3350, 3352, + 5, 5, 0, 0, 3351, 3350, 1, 0, 0, 0, 3352, 3355, 1, 0, 0, 0, 3353, 3351, + 1, 0, 0, 0, 3353, 3354, 1, 0, 0, 0, 3354, 305, 1, 0, 0, 0, 3355, 3353, + 1, 0, 0, 0, 3356, 3358, 3, 308, 154, 0, 3357, 3356, 1, 0, 0, 0, 3358, 3359, + 1, 0, 0, 0, 3359, 3357, 1, 0, 0, 0, 3359, 3360, 1, 0, 0, 0, 3360, 307, + 1, 0, 0, 0, 3361, 3370, 3, 334, 167, 0, 3362, 3366, 5, 123, 0, 0, 3363, + 3365, 5, 5, 0, 0, 3364, 3363, 1, 0, 0, 0, 3365, 3368, 1, 0, 0, 0, 3366, + 3364, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3370, 1, 0, 0, 0, 3368, + 3366, 1, 0, 0, 0, 3369, 3361, 1, 0, 0, 0, 3369, 3362, 1, 0, 0, 0, 3370, + 309, 1, 0, 0, 0, 3371, 3372, 7, 20, 0, 0, 3372, 311, 1, 0, 0, 0, 3373, + 3374, 7, 21, 0, 0, 3374, 313, 1, 0, 0, 0, 3375, 3376, 7, 22, 0, 0, 3376, + 315, 1, 0, 0, 0, 3377, 3378, 7, 23, 0, 0, 3378, 317, 1, 0, 0, 0, 3379, + 3381, 3, 320, 160, 0, 3380, 3379, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, + 3380, 1, 0, 0, 0, 3382, 3383, 1, 0, 0, 0, 3383, 319, 1, 0, 0, 0, 3384, + 3388, 3, 330, 165, 0, 3385, 3387, 5, 5, 0, 0, 3386, 3385, 1, 0, 0, 0, 3387, + 3390, 1, 0, 0, 0, 3388, 3386, 1, 0, 0, 0, 3388, 3389, 1, 0, 0, 0, 3389, + 3400, 1, 0, 0, 0, 3390, 3388, 1, 0, 0, 0, 3391, 3395, 3, 316, 158, 0, 3392, + 3394, 5, 5, 0, 0, 3393, 3392, 1, 0, 0, 0, 3394, 3397, 1, 0, 0, 0, 3395, + 3393, 1, 0, 0, 0, 3395, 3396, 1, 0, 0, 0, 3396, 3400, 1, 0, 0, 0, 3397, + 3395, 1, 0, 0, 0, 3398, 3400, 3, 334, 167, 0, 3399, 3384, 1, 0, 0, 0, 3399, + 3391, 1, 0, 0, 0, 3399, 3398, 1, 0, 0, 0, 3400, 321, 1, 0, 0, 0, 3401, + 3402, 7, 24, 0, 0, 3402, 323, 1, 0, 0, 0, 3403, 3404, 5, 128, 0, 0, 3404, + 325, 1, 0, 0, 0, 3405, 3406, 7, 25, 0, 0, 3406, 327, 1, 0, 0, 0, 3407, + 3408, 7, 26, 0, 0, 3408, 329, 1, 0, 0, 0, 3409, 3410, 5, 133, 0, 0, 3410, + 331, 1, 0, 0, 0, 3411, 3412, 7, 27, 0, 0, 3412, 333, 1, 0, 0, 0, 3413, + 3416, 3, 336, 168, 0, 3414, 3416, 3, 338, 169, 0, 3415, 3413, 1, 0, 0, + 0, 3415, 3414, 1, 0, 0, 0, 3416, 3420, 1, 0, 0, 0, 3417, 3419, 5, 5, 0, + 0, 3418, 3417, 1, 0, 0, 0, 3419, 3422, 1, 0, 0, 0, 3420, 3418, 1, 0, 0, + 0, 3420, 3421, 1, 0, 0, 0, 3421, 335, 1, 0, 0, 0, 3422, 3420, 1, 0, 0, + 0, 3423, 3427, 3, 340, 170, 0, 3424, 3426, 5, 5, 0, 0, 3425, 3424, 1, 0, + 0, 0, 3426, 3429, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3427, 3428, 1, 0, + 0, 0, 3428, 3433, 1, 0, 0, 0, 3429, 3427, 1, 0, 0, 0, 3430, 3433, 5, 40, + 0, 0, 3431, 3433, 5, 42, 0, 0, 3432, 3423, 1, 0, 0, 0, 3432, 3430, 1, 0, + 0, 0, 3432, 3431, 1, 0, 0, 0, 3433, 3434, 1, 0, 0, 0, 3434, 3435, 3, 342, + 171, 0, 3435, 337, 1, 0, 0, 0, 3436, 3440, 3, 340, 170, 0, 3437, 3439, + 5, 5, 0, 0, 3438, 3437, 1, 0, 0, 0, 3439, 3442, 1, 0, 0, 0, 3440, 3438, + 1, 0, 0, 0, 3440, 3441, 1, 0, 0, 0, 3441, 3446, 1, 0, 0, 0, 3442, 3440, + 1, 0, 0, 0, 3443, 3446, 5, 40, 0, 0, 3444, 3446, 5, 42, 0, 0, 3445, 3436, + 1, 0, 0, 0, 3445, 3443, 1, 0, 0, 0, 3445, 3444, 1, 0, 0, 0, 3446, 3447, + 1, 0, 0, 0, 3447, 3449, 5, 11, 0, 0, 3448, 3450, 3, 342, 171, 0, 3449, + 3448, 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451, 3449, 1, 0, 0, 0, 3451, + 3452, 1, 0, 0, 0, 3452, 3453, 1, 0, 0, 0, 3453, 3454, 5, 12, 0, 0, 3454, + 339, 1, 0, 0, 0, 3455, 3456, 7, 0, 0, 0, 3456, 3460, 7, 28, 0, 0, 3457, + 3459, 5, 5, 0, 0, 3458, 3457, 1, 0, 0, 0, 3459, 3462, 1, 0, 0, 0, 3460, + 3458, 1, 0, 0, 0, 3460, 3461, 1, 0, 0, 0, 3461, 3463, 1, 0, 0, 0, 3462, + 3460, 1, 0, 0, 0, 3463, 3464, 5, 26, 0, 0, 3464, 341, 1, 0, 0, 0, 3465, + 3468, 3, 36, 18, 0, 3466, 3468, 3, 106, 53, 0, 3467, 3465, 1, 0, 0, 0, + 3467, 3466, 1, 0, 0, 0, 3468, 343, 1, 0, 0, 0, 3469, 3470, 7, 29, 0, 0, + 3470, 345, 1, 0, 0, 0, 3471, 3482, 3, 344, 172, 0, 3472, 3474, 5, 5, 0, + 0, 3473, 3472, 1, 0, 0, 0, 3474, 3477, 1, 0, 0, 0, 3475, 3473, 1, 0, 0, + 0, 3475, 3476, 1, 0, 0, 0, 3476, 3478, 1, 0, 0, 0, 3477, 3475, 1, 0, 0, + 0, 3478, 3479, 5, 7, 0, 0, 3479, 3481, 3, 344, 172, 0, 3480, 3475, 1, 0, + 0, 0, 3481, 3484, 1, 0, 0, 0, 3482, 3480, 1, 0, 0, 0, 3482, 3483, 1, 0, + 0, 0, 3483, 347, 1, 0, 0, 0, 3484, 3482, 1, 0, 0, 0, 535, 349, 354, 360, + 368, 374, 379, 385, 395, 404, 411, 418, 425, 430, 435, 441, 443, 448, 456, + 459, 466, 469, 475, 482, 486, 491, 498, 508, 511, 518, 521, 524, 529, 536, + 540, 545, 549, 554, 561, 565, 570, 574, 579, 586, 590, 593, 599, 602, 610, + 617, 626, 633, 640, 646, 652, 656, 658, 663, 669, 672, 677, 685, 692, 699, + 703, 709, 716, 722, 733, 737, 745, 751, 758, 763, 770, 779, 786, 793, 799, + 805, 809, 814, 820, 825, 832, 839, 843, 849, 856, 863, 869, 875, 882, 889, + 896, 900, 907, 913, 919, 925, 932, 936, 941, 948, 952, 957, 961, 967, 974, + 981, 987, 993, 997, 999, 1004, 1010, 1016, 1023, 1027, 1030, 1036, 1040, + 1045, 1052, 1057, 1062, 1069, 1076, 1083, 1087, 1092, 1096, 1101, 1105, + 1112, 1116, 1121, 1127, 1134, 1141, 1145, 1151, 1158, 1165, 1171, 1177, + 1181, 1186, 1192, 1198, 1202, 1207, 1214, 1219, 1224, 1229, 1234, 1238, + 1243, 1250, 1255, 1257, 1262, 1265, 1270, 1274, 1279, 1283, 1286, 1289, + 1294, 1298, 1301, 1303, 1309, 1315, 1321, 1328, 1335, 1342, 1346, 1351, + 1355, 1358, 1364, 1371, 1378, 1382, 1387, 1394, 1401, 1405, 1410, 1415, + 1421, 1428, 1435, 1441, 1447, 1451, 1453, 1458, 1464, 1470, 1477, 1481, + 1487, 1494, 1498, 1504, 1511, 1517, 1523, 1530, 1537, 1541, 1546, 1550, + 1553, 1559, 1566, 1573, 1577, 1582, 1586, 1592, 1601, 1605, 1610, 1617, + 1621, 1626, 1635, 1642, 1648, 1654, 1658, 1664, 1667, 1673, 1677, 1682, + 1686, 1689, 1696, 1700, 1704, 1709, 1715, 1723, 1730, 1736, 1743, 1747, + 1750, 1754, 1759, 1765, 1769, 1775, 1782, 1785, 1791, 1798, 1807, 1812, + 1817, 1824, 1829, 1833, 1839, 1843, 1848, 1857, 1864, 1870, 1875, 1881, + 1886, 1891, 1897, 1901, 1906, 1913, 1917, 1921, 1929, 1932, 1935, 1939, + 1941, 1948, 1955, 1960, 1966, 1973, 1981, 1987, 1994, 1999, 2007, 2011, + 2017, 2026, 2031, 2037, 2041, 2046, 2053, 2066, 2071, 2080, 2086, 2094, + 2101, 2107, 2114, 2121, 2127, 2135, 2142, 2150, 2157, 2164, 2172, 2181, + 2186, 2188, 2195, 2202, 2209, 2220, 2227, 2235, 2241, 2249, 2256, 2264, + 2271, 2278, 2285, 2292, 2298, 2309, 2312, 2318, 2326, 2333, 2339, 2346, + 2353, 2359, 2366, 2374, 2380, 2387, 2394, 2400, 2406, 2410, 2415, 2424, + 2430, 2433, 2436, 2440, 2445, 2449, 2454, 2463, 2470, 2477, 2483, 2489, + 2493, 2498, 2507, 2514, 2521, 2527, 2533, 2537, 2542, 2545, 2550, 2555, + 2562, 2569, 2572, 2575, 2580, 2599, 2605, 2612, 2621, 2628, 2635, 2641, + 2647, 2651, 2656, 2659, 2667, 2672, 2674, 2683, 2685, 2696, 2703, 2714, + 2721, 2730, 2734, 2739, 2746, 2749, 2755, 2764, 2771, 2777, 2783, 2787, + 2794, 2801, 2805, 2807, 2813, 2820, 2825, 2830, 2837, 2844, 2848, 2853, + 2857, 2862, 2866, 2870, 2876, 2883, 2890, 2893, 2898, 2902, 2911, 2918, + 2923, 2927, 2930, 2936, 2943, 2950, 2957, 2962, 2967, 2971, 2976, 2983, + 2988, 2991, 2997, 3003, 3010, 3017, 3024, 3027, 3036, 3040, 3045, 3052, + 3059, 3064, 3070, 3079, 3086, 3092, 3098, 3102, 3107, 3114, 3119, 3125, + 3132, 3137, 3139, 3144, 3150, 3159, 3168, 3175, 3181, 3186, 3190, 3195, + 3199, 3205, 3212, 3221, 3225, 3231, 3240, 3249, 3255, 3261, 3264, 3270, + 3275, 3298, 3304, 3311, 3318, 3323, 3330, 3332, 3336, 3338, 3348, 3353, + 3359, 3366, 3369, 3382, 3388, 3395, 3399, 3415, 3420, 3427, 3432, 3440, + 3445, 3451, 3460, 3467, 3475, 3482, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// KotlinParserInit initializes any static state used to implement KotlinParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewKotlinParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func KotlinParserInit() { + staticData := &kotlinparserParserStaticData + staticData.once.Do(kotlinparserParserInit) +} + +// NewKotlinParser produces a new parser instance for the optional input antlr.TokenStream. +func NewKotlinParser(input antlr.TokenStream) *KotlinParser { + KotlinParserInit() + this := new(KotlinParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &kotlinparserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.predictionContextCache) + this.RuleNames = staticData.ruleNames + this.LiteralNames = staticData.literalNames + this.SymbolicNames = staticData.symbolicNames + this.GrammarFileName = "java-escape" + + return this +} + +// KotlinParser tokens. +const ( + KotlinParserEOF = antlr.TokenEOF + KotlinParserShebangLine = 1 + KotlinParserDelimitedComment = 2 + KotlinParserLineComment = 3 + KotlinParserWS = 4 + KotlinParserNL = 5 + KotlinParserRESERVED = 6 + KotlinParserDOT = 7 + KotlinParserCOMMA = 8 + KotlinParserLPAREN = 9 + KotlinParserRPAREN = 10 + KotlinParserLSQUARE = 11 + KotlinParserRSQUARE = 12 + KotlinParserLCURL = 13 + KotlinParserRCURL = 14 + KotlinParserMULT = 15 + KotlinParserMOD = 16 + KotlinParserDIV = 17 + KotlinParserADD = 18 + KotlinParserSUB = 19 + KotlinParserINCR = 20 + KotlinParserDECR = 21 + KotlinParserCONJ = 22 + KotlinParserDISJ = 23 + KotlinParserEXCL_WS = 24 + KotlinParserEXCL_NO_WS = 25 + KotlinParserCOLON = 26 + KotlinParserSEMICOLON = 27 + KotlinParserASSIGNMENT = 28 + KotlinParserADD_ASSIGNMENT = 29 + KotlinParserSUB_ASSIGNMENT = 30 + KotlinParserMULT_ASSIGNMENT = 31 + KotlinParserDIV_ASSIGNMENT = 32 + KotlinParserMOD_ASSIGNMENT = 33 + KotlinParserARROW = 34 + KotlinParserDOUBLE_ARROW = 35 + KotlinParserRANGE = 36 + KotlinParserCOLONCOLON = 37 + KotlinParserDOUBLE_SEMICOLON = 38 + KotlinParserHASH = 39 + KotlinParserAT_NO_WS = 40 + KotlinParserAT_POST_WS = 41 + KotlinParserAT_PRE_WS = 42 + KotlinParserAT_BOTH_WS = 43 + KotlinParserQUEST_WS = 44 + KotlinParserQUEST_NO_WS = 45 + KotlinParserLANGLE = 46 + KotlinParserRANGLE = 47 + KotlinParserLE = 48 + KotlinParserGE = 49 + KotlinParserEXCL_EQ = 50 + KotlinParserEXCL_EQEQ = 51 + KotlinParserAS_SAFE = 52 + KotlinParserEQEQ = 53 + KotlinParserEQEQEQ = 54 + KotlinParserSINGLE_QUOTE = 55 + KotlinParserAMP = 56 + KotlinParserRETURN_AT = 57 + KotlinParserCONTINUE_AT = 58 + KotlinParserBREAK_AT = 59 + KotlinParserTHIS_AT = 60 + KotlinParserSUPER_AT = 61 + KotlinParserFILE = 62 + KotlinParserFIELD = 63 + KotlinParserPROPERTY = 64 + KotlinParserGET = 65 + KotlinParserSET = 66 + KotlinParserRECEIVER = 67 + KotlinParserPARAM = 68 + KotlinParserSETPARAM = 69 + KotlinParserDELEGATE = 70 + KotlinParserPACKAGE = 71 + KotlinParserIMPORT = 72 + KotlinParserCLASS = 73 + KotlinParserINTERFACE = 74 + KotlinParserFUN = 75 + KotlinParserOBJECT = 76 + KotlinParserVAL = 77 + KotlinParserVAR = 78 + KotlinParserTYPE_ALIAS = 79 + KotlinParserCONSTRUCTOR = 80 + KotlinParserBY = 81 + KotlinParserCOMPANION = 82 + KotlinParserINIT = 83 + KotlinParserTHIS = 84 + KotlinParserSUPER = 85 + KotlinParserTYPEOF = 86 + KotlinParserWHERE = 87 + KotlinParserIF = 88 + KotlinParserELSE = 89 + KotlinParserWHEN = 90 + KotlinParserTRY = 91 + KotlinParserCATCH = 92 + KotlinParserFINALLY = 93 + KotlinParserFOR = 94 + KotlinParserDO = 95 + KotlinParserWHILE = 96 + KotlinParserTHROW = 97 + KotlinParserRETURN = 98 + KotlinParserCONTINUE = 99 + KotlinParserBREAK = 100 + KotlinParserAS = 101 + KotlinParserIS = 102 + KotlinParserIN = 103 + KotlinParserNOT_IS = 104 + KotlinParserNOT_IN = 105 + KotlinParserOUT = 106 + KotlinParserDYNAMIC = 107 + KotlinParserPUBLIC = 108 + KotlinParserPRIVATE = 109 + KotlinParserPROTECTED = 110 + KotlinParserINTERNAL = 111 + KotlinParserENUM = 112 + KotlinParserSEALED = 113 + KotlinParserANNOTATION = 114 + KotlinParserDATA = 115 + KotlinParserINNER = 116 + KotlinParserVALUE = 117 + KotlinParserTAILREC = 118 + KotlinParserOPERATOR = 119 + KotlinParserINLINE = 120 + KotlinParserINFIX = 121 + KotlinParserEXTERNAL = 122 + KotlinParserSUSPEND = 123 + KotlinParserOVERRIDE = 124 + KotlinParserABSTRACT = 125 + KotlinParserFINAL = 126 + KotlinParserOPEN = 127 + KotlinParserCONST = 128 + KotlinParserLATEINIT = 129 + KotlinParserVARARG = 130 + KotlinParserNOINLINE = 131 + KotlinParserCROSSINLINE = 132 + KotlinParserREIFIED = 133 + KotlinParserEXPECT = 134 + KotlinParserACTUAL = 135 + KotlinParserRealLiteral = 136 + KotlinParserFloatLiteral = 137 + KotlinParserDoubleLiteral = 138 + KotlinParserIntegerLiteral = 139 + KotlinParserHexLiteral = 140 + KotlinParserBinLiteral = 141 + KotlinParserUnsignedLiteral = 142 + KotlinParserLongLiteral = 143 + KotlinParserBooleanLiteral = 144 + KotlinParserNullLiteral = 145 + KotlinParserCharacterLiteral = 146 + KotlinParserIdentifier = 147 + KotlinParserIdentifierOrSoftKey = 148 + KotlinParserFieldIdentifier = 149 + KotlinParserQUOTE_OPEN = 150 + KotlinParserTRIPLE_QUOTE_OPEN = 151 + KotlinParserUNICODE_CLASS_LL = 152 + KotlinParserUNICODE_CLASS_LM = 153 + KotlinParserUNICODE_CLASS_LO = 154 + KotlinParserUNICODE_CLASS_LT = 155 + KotlinParserUNICODE_CLASS_LU = 156 + KotlinParserUNICODE_CLASS_ND = 157 + KotlinParserUNICODE_CLASS_NL = 158 + KotlinParserQUOTE_CLOSE = 159 + KotlinParserLineStrRef = 160 + KotlinParserLineStrText = 161 + KotlinParserLineStrEscapedChar = 162 + KotlinParserLineStrExprStart = 163 + KotlinParserTRIPLE_QUOTE_CLOSE = 164 + KotlinParserMultiLineStringQuote = 165 + KotlinParserMultiLineStrRef = 166 + KotlinParserMultiLineStrText = 167 + KotlinParserMultiLineStrExprStart = 168 + KotlinParserInside_Comment = 169 + KotlinParserInside_WS = 170 + KotlinParserInside_NL = 171 + KotlinParserErrorCharacter = 172 +) + +// KotlinParser rules. +const ( + KotlinParserRULE_kotlinFile = 0 + KotlinParserRULE_script = 1 + KotlinParserRULE_shebangLine = 2 + KotlinParserRULE_fileAnnotation = 3 + KotlinParserRULE_packageHeader = 4 + KotlinParserRULE_importList = 5 + KotlinParserRULE_importHeader = 6 + KotlinParserRULE_importAlias = 7 + KotlinParserRULE_topLevelObject = 8 + KotlinParserRULE_typeAlias = 9 + KotlinParserRULE_declaration = 10 + KotlinParserRULE_classDeclaration = 11 + KotlinParserRULE_primaryConstructor = 12 + KotlinParserRULE_classBody = 13 + KotlinParserRULE_classParameters = 14 + KotlinParserRULE_classParameter = 15 + KotlinParserRULE_delegationSpecifiers = 16 + KotlinParserRULE_delegationSpecifier = 17 + KotlinParserRULE_constructorInvocation = 18 + KotlinParserRULE_annotatedDelegationSpecifier = 19 + KotlinParserRULE_explicitDelegation = 20 + KotlinParserRULE_typeParameters = 21 + KotlinParserRULE_typeParameter = 22 + KotlinParserRULE_typeConstraints = 23 + KotlinParserRULE_typeConstraint = 24 + KotlinParserRULE_classMemberDeclarations = 25 + KotlinParserRULE_classMemberDeclaration = 26 + KotlinParserRULE_anonymousInitializer = 27 + KotlinParserRULE_companionObject = 28 + KotlinParserRULE_functionValueParameters = 29 + KotlinParserRULE_functionValueParameter = 30 + KotlinParserRULE_functionDeclaration = 31 + KotlinParserRULE_functionBody = 32 + KotlinParserRULE_variableDeclaration = 33 + KotlinParserRULE_multiVariableDeclaration = 34 + KotlinParserRULE_propertyDeclaration = 35 + KotlinParserRULE_propertyDelegate = 36 + KotlinParserRULE_getter = 37 + KotlinParserRULE_setter = 38 + KotlinParserRULE_parametersWithOptionalType = 39 + KotlinParserRULE_functionValueParameterWithOptionalType = 40 + KotlinParserRULE_parameterWithOptionalType = 41 + KotlinParserRULE_parameter = 42 + KotlinParserRULE_objectDeclaration = 43 + KotlinParserRULE_secondaryConstructor = 44 + KotlinParserRULE_constructorDelegationCall = 45 + KotlinParserRULE_enumClassBody = 46 + KotlinParserRULE_enumEntries = 47 + KotlinParserRULE_enumEntry = 48 + KotlinParserRULE_type = 49 + KotlinParserRULE_typeReference = 50 + KotlinParserRULE_nullableType = 51 + KotlinParserRULE_quest = 52 + KotlinParserRULE_userType = 53 + KotlinParserRULE_simpleUserType = 54 + KotlinParserRULE_typeProjection = 55 + KotlinParserRULE_typeProjectionModifiers = 56 + KotlinParserRULE_typeProjectionModifier = 57 + KotlinParserRULE_functionType = 58 + KotlinParserRULE_functionTypeParameters = 59 + KotlinParserRULE_parenthesizedType = 60 + KotlinParserRULE_receiverType = 61 + KotlinParserRULE_parenthesizedUserType = 62 + KotlinParserRULE_definitelyNonNullableType = 63 + KotlinParserRULE_statements = 64 + KotlinParserRULE_statement = 65 + KotlinParserRULE_label = 66 + KotlinParserRULE_controlStructureBody = 67 + KotlinParserRULE_block = 68 + KotlinParserRULE_loopStatement = 69 + KotlinParserRULE_forStatement = 70 + KotlinParserRULE_whileStatement = 71 + KotlinParserRULE_doWhileStatement = 72 + KotlinParserRULE_assignment = 73 + KotlinParserRULE_semi = 74 + KotlinParserRULE_semis = 75 + KotlinParserRULE_expression = 76 + KotlinParserRULE_disjunction = 77 + KotlinParserRULE_conjunction = 78 + KotlinParserRULE_equality = 79 + KotlinParserRULE_comparison = 80 + KotlinParserRULE_genericCallLikeComparison = 81 + KotlinParserRULE_infixOperation = 82 + KotlinParserRULE_elvisExpression = 83 + KotlinParserRULE_elvis = 84 + KotlinParserRULE_infixFunctionCall = 85 + KotlinParserRULE_rangeExpression = 86 + KotlinParserRULE_additiveExpression = 87 + KotlinParserRULE_multiplicativeExpression = 88 + KotlinParserRULE_asExpression = 89 + KotlinParserRULE_prefixUnaryExpression = 90 + KotlinParserRULE_unaryPrefix = 91 + KotlinParserRULE_postfixUnaryExpression = 92 + KotlinParserRULE_postfixUnarySuffix = 93 + KotlinParserRULE_directlyAssignableExpression = 94 + KotlinParserRULE_parenthesizedDirectlyAssignableExpression = 95 + KotlinParserRULE_assignableExpression = 96 + KotlinParserRULE_parenthesizedAssignableExpression = 97 + KotlinParserRULE_assignableSuffix = 98 + KotlinParserRULE_indexingSuffix = 99 + KotlinParserRULE_navigationSuffix = 100 + KotlinParserRULE_callSuffix = 101 + KotlinParserRULE_annotatedLambda = 102 + KotlinParserRULE_typeArguments = 103 + KotlinParserRULE_valueArguments = 104 + KotlinParserRULE_valueArgument = 105 + KotlinParserRULE_primaryExpression = 106 + KotlinParserRULE_parenthesizedExpression = 107 + KotlinParserRULE_collectionLiteral = 108 + KotlinParserRULE_literalConstant = 109 + KotlinParserRULE_stringLiteral = 110 + KotlinParserRULE_lineStringLiteral = 111 + KotlinParserRULE_multiLineStringLiteral = 112 + KotlinParserRULE_lineStringContent = 113 + KotlinParserRULE_lineStringExpression = 114 + KotlinParserRULE_multiLineStringContent = 115 + KotlinParserRULE_multiLineStringExpression = 116 + KotlinParserRULE_lambdaLiteral = 117 + KotlinParserRULE_lambdaParameters = 118 + KotlinParserRULE_lambdaParameter = 119 + KotlinParserRULE_anonymousFunction = 120 + KotlinParserRULE_functionLiteral = 121 + KotlinParserRULE_objectLiteral = 122 + KotlinParserRULE_thisExpression = 123 + KotlinParserRULE_superExpression = 124 + KotlinParserRULE_ifExpression = 125 + KotlinParserRULE_whenSubject = 126 + KotlinParserRULE_whenExpression = 127 + KotlinParserRULE_whenEntry = 128 + KotlinParserRULE_whenCondition = 129 + KotlinParserRULE_rangeTest = 130 + KotlinParserRULE_typeTest = 131 + KotlinParserRULE_tryExpression = 132 + KotlinParserRULE_catchBlock = 133 + KotlinParserRULE_finallyBlock = 134 + KotlinParserRULE_jumpExpression = 135 + KotlinParserRULE_callableReference = 136 + KotlinParserRULE_assignmentAndOperator = 137 + KotlinParserRULE_equalityOperator = 138 + KotlinParserRULE_comparisonOperator = 139 + KotlinParserRULE_inOperator = 140 + KotlinParserRULE_isOperator = 141 + KotlinParserRULE_additiveOperator = 142 + KotlinParserRULE_multiplicativeOperator = 143 + KotlinParserRULE_asOperator = 144 + KotlinParserRULE_prefixUnaryOperator = 145 + KotlinParserRULE_postfixUnaryOperator = 146 + KotlinParserRULE_excl = 147 + KotlinParserRULE_memberAccessOperator = 148 + KotlinParserRULE_safeNav = 149 + KotlinParserRULE_modifiers = 150 + KotlinParserRULE_parameterModifiers = 151 + KotlinParserRULE_modifier = 152 + KotlinParserRULE_typeModifiers = 153 + KotlinParserRULE_typeModifier = 154 + KotlinParserRULE_classModifier = 155 + KotlinParserRULE_memberModifier = 156 + KotlinParserRULE_visibilityModifier = 157 + KotlinParserRULE_varianceModifier = 158 + KotlinParserRULE_typeParameterModifiers = 159 + KotlinParserRULE_typeParameterModifier = 160 + KotlinParserRULE_functionModifier = 161 + KotlinParserRULE_propertyModifier = 162 + KotlinParserRULE_inheritanceModifier = 163 + KotlinParserRULE_parameterModifier = 164 + KotlinParserRULE_reificationModifier = 165 + KotlinParserRULE_platformModifier = 166 + KotlinParserRULE_annotation = 167 + KotlinParserRULE_singleAnnotation = 168 + KotlinParserRULE_multiAnnotation = 169 + KotlinParserRULE_annotationUseSiteTarget = 170 + KotlinParserRULE_unescapedAnnotation = 171 + KotlinParserRULE_simpleIdentifier = 172 + KotlinParserRULE_identifier = 173 +) + +// IKotlinFileContext is an interface to support dynamic dispatch. +type IKotlinFileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsKotlinFileContext differentiates from other interfaces. + IsKotlinFileContext() +} + +type KotlinFileContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKotlinFileContext() *KotlinFileContext { + var p = new(KotlinFileContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_kotlinFile + return p +} + +func (*KotlinFileContext) IsKotlinFileContext() {} + +func NewKotlinFileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KotlinFileContext { + var p = new(KotlinFileContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_kotlinFile + + return p +} + +func (s *KotlinFileContext) GetParser() antlr.Parser { return s.parser } + +func (s *KotlinFileContext) PackageHeader() IPackageHeaderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackageHeaderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackageHeaderContext) +} + +func (s *KotlinFileContext) ImportList() IImportListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportListContext) +} + +func (s *KotlinFileContext) EOF() antlr.TerminalNode { + return s.GetToken(KotlinParserEOF, 0) +} + +func (s *KotlinFileContext) ShebangLine() IShebangLineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShebangLineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShebangLineContext) +} + +func (s *KotlinFileContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *KotlinFileContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *KotlinFileContext) AllFileAnnotation() []IFileAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFileAnnotationContext); ok { + len++ + } + } + + tst := make([]IFileAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFileAnnotationContext); ok { + tst[i] = t.(IFileAnnotationContext) + i++ + } + } + + return tst +} + +func (s *KotlinFileContext) FileAnnotation(i int) IFileAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFileAnnotationContext) +} + +func (s *KotlinFileContext) AllTopLevelObject() []ITopLevelObjectContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITopLevelObjectContext); ok { + len++ + } + } + + tst := make([]ITopLevelObjectContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITopLevelObjectContext); ok { + tst[i] = t.(ITopLevelObjectContext) + i++ + } + } + + return tst +} + +func (s *KotlinFileContext) TopLevelObject(i int) ITopLevelObjectContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITopLevelObjectContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITopLevelObjectContext) +} + +func (s *KotlinFileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KotlinFileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KotlinFileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterKotlinFile(s) + } +} + +func (s *KotlinFileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitKotlinFile(s) + } +} + +func (p *KotlinParser) KotlinFile() (localctx IKotlinFileContext) { + this := p + _ = this + + localctx = NewKotlinFileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, KotlinParserRULE_kotlinFile) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(349) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserShebangLine { + { + p.SetState(348) + p.ShebangLine() + } + + } + p.SetState(354) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(351) + p.Match(KotlinParserNL) + } + + p.SetState(356) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(360) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(357) + p.FileAnnotation() + } + + } + p.SetState(362) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) + } + { + p.SetState(363) + p.PackageHeader() + } + { + p.SetState(364) + p.ImportList() + } + p.SetState(368) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&8070450497888190591) != 0 { + { + p.SetState(365) + p.TopLevelObject() + } + + p.SetState(370) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(371) + p.Match(KotlinParserEOF) + } + + return localctx +} + +// IScriptContext is an interface to support dynamic dispatch. +type IScriptContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsScriptContext differentiates from other interfaces. + IsScriptContext() +} + +type ScriptContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyScriptContext() *ScriptContext { + var p = new(ScriptContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_script + return p +} + +func (*ScriptContext) IsScriptContext() {} + +func NewScriptContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScriptContext { + var p = new(ScriptContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_script + + return p +} + +func (s *ScriptContext) GetParser() antlr.Parser { return s.parser } + +func (s *ScriptContext) PackageHeader() IPackageHeaderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackageHeaderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackageHeaderContext) +} + +func (s *ScriptContext) ImportList() IImportListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportListContext) +} + +func (s *ScriptContext) EOF() antlr.TerminalNode { + return s.GetToken(KotlinParserEOF, 0) +} + +func (s *ScriptContext) ShebangLine() IShebangLineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShebangLineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShebangLineContext) +} + +func (s *ScriptContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ScriptContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ScriptContext) AllFileAnnotation() []IFileAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFileAnnotationContext); ok { + len++ + } + } + + tst := make([]IFileAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFileAnnotationContext); ok { + tst[i] = t.(IFileAnnotationContext) + i++ + } + } + + return tst +} + +func (s *ScriptContext) FileAnnotation(i int) IFileAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFileAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFileAnnotationContext) +} + +func (s *ScriptContext) AllStatement() []IStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementContext); ok { + len++ + } + } + + tst := make([]IStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementContext); ok { + tst[i] = t.(IStatementContext) + i++ + } + } + + return tst +} + +func (s *ScriptContext) Statement(i int) IStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *ScriptContext) AllSemi() []ISemiContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISemiContext); ok { + len++ + } + } + + tst := make([]ISemiContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISemiContext); ok { + tst[i] = t.(ISemiContext) + i++ + } + } + + return tst +} + +func (s *ScriptContext) Semi(i int) ISemiContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemiContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISemiContext) +} + +func (s *ScriptContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ScriptContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ScriptContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterScript(s) + } +} + +func (s *ScriptContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitScript(s) + } +} + +func (p *KotlinParser) Script() (localctx IScriptContext) { + this := p + _ = this + + localctx = NewScriptContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, KotlinParserRULE_script) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(374) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserShebangLine { + { + p.SetState(373) + p.ShebangLine() + } + + } + p.SetState(379) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(376) + p.Match(KotlinParserNL) + } + + p.SetState(381) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(385) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(382) + p.FileAnnotation() + } + + } + p.SetState(387) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) + } + { + p.SetState(388) + p.PackageHeader() + } + { + p.SetState(389) + p.ImportList() + } + p.SetState(395) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-144109553024488960) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-4260645306497) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&13629951) != 0 { + { + p.SetState(390) + p.Statement() + } + { + p.SetState(391) + p.Semi() + } + + p.SetState(397) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(398) + p.Match(KotlinParserEOF) + } + + return localctx +} + +// IShebangLineContext is an interface to support dynamic dispatch. +type IShebangLineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsShebangLineContext differentiates from other interfaces. + IsShebangLineContext() +} + +type ShebangLineContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShebangLineContext() *ShebangLineContext { + var p = new(ShebangLineContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_shebangLine + return p +} + +func (*ShebangLineContext) IsShebangLineContext() {} + +func NewShebangLineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShebangLineContext { + var p = new(ShebangLineContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_shebangLine + + return p +} + +func (s *ShebangLineContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShebangLineContext) ShebangLine() antlr.TerminalNode { + return s.GetToken(KotlinParserShebangLine, 0) +} + +func (s *ShebangLineContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ShebangLineContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ShebangLineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShebangLineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShebangLineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterShebangLine(s) + } +} + +func (s *ShebangLineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitShebangLine(s) + } +} + +func (p *KotlinParser) ShebangLine() (localctx IShebangLineContext) { + this := p + _ = this + + localctx = NewShebangLineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, KotlinParserRULE_shebangLine) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(400) + p.Match(KotlinParserShebangLine) + } + p.SetState(402) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(401) + p.Match(KotlinParserNL) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(404) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) + } + + return localctx +} + +// IFileAnnotationContext is an interface to support dynamic dispatch. +type IFileAnnotationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFileAnnotationContext differentiates from other interfaces. + IsFileAnnotationContext() +} + +type FileAnnotationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFileAnnotationContext() *FileAnnotationContext { + var p = new(FileAnnotationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_fileAnnotation + return p +} + +func (*FileAnnotationContext) IsFileAnnotationContext() {} + +func NewFileAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FileAnnotationContext { + var p = new(FileAnnotationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_fileAnnotation + + return p +} + +func (s *FileAnnotationContext) GetParser() antlr.Parser { return s.parser } + +func (s *FileAnnotationContext) FILE() antlr.TerminalNode { + return s.GetToken(KotlinParserFILE, 0) +} + +func (s *FileAnnotationContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *FileAnnotationContext) AT_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_NO_WS, 0) +} + +func (s *FileAnnotationContext) AT_PRE_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_PRE_WS, 0) +} + +func (s *FileAnnotationContext) LSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserLSQUARE, 0) +} + +func (s *FileAnnotationContext) RSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserRSQUARE, 0) +} + +func (s *FileAnnotationContext) AllUnescapedAnnotation() []IUnescapedAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnescapedAnnotationContext); ok { + len++ + } + } + + tst := make([]IUnescapedAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnescapedAnnotationContext); ok { + tst[i] = t.(IUnescapedAnnotationContext) + i++ + } + } + + return tst +} + +func (s *FileAnnotationContext) UnescapedAnnotation(i int) IUnescapedAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnescapedAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnescapedAnnotationContext) +} + +func (s *FileAnnotationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FileAnnotationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FileAnnotationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FileAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FileAnnotationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFileAnnotation(s) + } +} + +func (s *FileAnnotationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFileAnnotation(s) + } +} + +func (p *KotlinParser) FileAnnotation() (localctx IFileAnnotationContext) { + this := p + _ = this + + localctx = NewFileAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, KotlinParserRULE_fileAnnotation) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(406) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(407) + p.Match(KotlinParserFILE) + } + p.SetState(411) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(408) + p.Match(KotlinParserNL) + } + + p.SetState(413) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(414) + p.Match(KotlinParserCOLON) + } + p.SetState(418) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(415) + p.Match(KotlinParserNL) + } + + p.SetState(420) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(430) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLSQUARE: + { + p.SetState(421) + p.Match(KotlinParserLSQUARE) + } + p.SetState(423) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = (int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&-17588927330817) != 0 || (int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&2098175) != 0 { + { + p.SetState(422) + p.UnescapedAnnotation() + } + + p.SetState(425) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(427) + p.Match(KotlinParserRSQUARE) + } + + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(429) + p.UnescapedAnnotation() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + p.SetState(435) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(432) + p.Match(KotlinParserNL) + } + + p.SetState(437) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + return localctx +} + +// IPackageHeaderContext is an interface to support dynamic dispatch. +type IPackageHeaderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPackageHeaderContext differentiates from other interfaces. + IsPackageHeaderContext() +} + +type PackageHeaderContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackageHeaderContext() *PackageHeaderContext { + var p = new(PackageHeaderContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_packageHeader + return p +} + +func (*PackageHeaderContext) IsPackageHeaderContext() {} + +func NewPackageHeaderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageHeaderContext { + var p = new(PackageHeaderContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_packageHeader + + return p +} + +func (s *PackageHeaderContext) GetParser() antlr.Parser { return s.parser } + +func (s *PackageHeaderContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(KotlinParserPACKAGE, 0) +} + +func (s *PackageHeaderContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PackageHeaderContext) Semi() ISemiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISemiContext) +} + +func (s *PackageHeaderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PackageHeaderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PackageHeaderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPackageHeader(s) + } +} + +func (s *PackageHeaderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPackageHeader(s) + } +} + +func (p *KotlinParser) PackageHeader() (localctx IPackageHeaderContext) { + this := p + _ = this + + localctx = NewPackageHeaderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, KotlinParserRULE_packageHeader) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(443) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserPACKAGE { + { + p.SetState(438) + p.Match(KotlinParserPACKAGE) + } + { + p.SetState(439) + p.Identifier() + } + p.SetState(441) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserNL || _la == KotlinParserSEMICOLON { + { + p.SetState(440) + p.Semi() + } + + } + + } + + return localctx +} + +// IImportListContext is an interface to support dynamic dispatch. +type IImportListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsImportListContext differentiates from other interfaces. + IsImportListContext() +} + +type ImportListContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportListContext() *ImportListContext { + var p = new(ImportListContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_importList + return p +} + +func (*ImportListContext) IsImportListContext() {} + +func NewImportListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportListContext { + var p = new(ImportListContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_importList + + return p +} + +func (s *ImportListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportListContext) AllImportHeader() []IImportHeaderContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IImportHeaderContext); ok { + len++ + } + } + + tst := make([]IImportHeaderContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IImportHeaderContext); ok { + tst[i] = t.(IImportHeaderContext) + i++ + } + } + + return tst +} + +func (s *ImportListContext) ImportHeader(i int) IImportHeaderContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportHeaderContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IImportHeaderContext) +} + +func (s *ImportListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterImportList(s) + } +} + +func (s *ImportListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitImportList(s) + } +} + +func (p *KotlinParser) ImportList() (localctx IImportListContext) { + this := p + _ = this + + localctx = NewImportListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, KotlinParserRULE_importList) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(448) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(445) + p.ImportHeader() + } + + } + p.SetState(450) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) + } + + return localctx +} + +// IImportHeaderContext is an interface to support dynamic dispatch. +type IImportHeaderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsImportHeaderContext differentiates from other interfaces. + IsImportHeaderContext() +} + +type ImportHeaderContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportHeaderContext() *ImportHeaderContext { + var p = new(ImportHeaderContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_importHeader + return p +} + +func (*ImportHeaderContext) IsImportHeaderContext() {} + +func NewImportHeaderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportHeaderContext { + var p = new(ImportHeaderContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_importHeader + + return p +} + +func (s *ImportHeaderContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportHeaderContext) IMPORT() antlr.TerminalNode { + return s.GetToken(KotlinParserIMPORT, 0) +} + +func (s *ImportHeaderContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ImportHeaderContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *ImportHeaderContext) MULT() antlr.TerminalNode { + return s.GetToken(KotlinParserMULT, 0) +} + +func (s *ImportHeaderContext) ImportAlias() IImportAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportAliasContext) +} + +func (s *ImportHeaderContext) Semi() ISemiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISemiContext) +} + +func (s *ImportHeaderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportHeaderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportHeaderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterImportHeader(s) + } +} + +func (s *ImportHeaderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitImportHeader(s) + } +} + +func (p *KotlinParser) ImportHeader() (localctx IImportHeaderContext) { + this := p + _ = this + + localctx = NewImportHeaderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, KotlinParserRULE_importHeader) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(451) + p.Match(KotlinParserIMPORT) + } + { + p.SetState(452) + p.Identifier() + } + p.SetState(456) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserDOT: + { + p.SetState(453) + p.Match(KotlinParserDOT) + } + { + p.SetState(454) + p.Match(KotlinParserMULT) + } + + case KotlinParserAS: + { + p.SetState(455) + p.ImportAlias() + } + + case KotlinParserEOF, KotlinParserNL, KotlinParserLPAREN, KotlinParserLSQUARE, KotlinParserLCURL, KotlinParserADD, KotlinParserSUB, KotlinParserINCR, KotlinParserDECR, KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS, KotlinParserSEMICOLON, KotlinParserCOLONCOLON, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserRETURN_AT, KotlinParserCONTINUE_AT, KotlinParserBREAK_AT, KotlinParserTHIS_AT, KotlinParserSUPER_AT, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCLASS, KotlinParserINTERFACE, KotlinParserFUN, KotlinParserOBJECT, KotlinParserVAL, KotlinParserVAR, KotlinParserTYPE_ALIAS, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserTHIS, KotlinParserSUPER, KotlinParserWHERE, KotlinParserIF, KotlinParserWHEN, KotlinParserTRY, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserFOR, KotlinParserDO, KotlinParserWHILE, KotlinParserTHROW, KotlinParserRETURN, KotlinParserCONTINUE, KotlinParserBREAK, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserRealLiteral, KotlinParserIntegerLiteral, KotlinParserHexLiteral, KotlinParserBinLiteral, KotlinParserUnsignedLiteral, KotlinParserLongLiteral, KotlinParserBooleanLiteral, KotlinParserNullLiteral, KotlinParserCharacterLiteral, KotlinParserIdentifier, KotlinParserQUOTE_OPEN, KotlinParserTRIPLE_QUOTE_OPEN: + + default: + } + p.SetState(459) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserNL || _la == KotlinParserSEMICOLON { + { + p.SetState(458) + p.Semi() + } + + } + + return localctx +} + +// IImportAliasContext is an interface to support dynamic dispatch. +type IImportAliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsImportAliasContext differentiates from other interfaces. + IsImportAliasContext() +} + +type ImportAliasContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportAliasContext() *ImportAliasContext { + var p = new(ImportAliasContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_importAlias + return p +} + +func (*ImportAliasContext) IsImportAliasContext() {} + +func NewImportAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportAliasContext { + var p = new(ImportAliasContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_importAlias + + return p +} + +func (s *ImportAliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportAliasContext) AS() antlr.TerminalNode { + return s.GetToken(KotlinParserAS, 0) +} + +func (s *ImportAliasContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ImportAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterImportAlias(s) + } +} + +func (s *ImportAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitImportAlias(s) + } +} + +func (p *KotlinParser) ImportAlias() (localctx IImportAliasContext) { + this := p + _ = this + + localctx = NewImportAliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, KotlinParserRULE_importAlias) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(461) + p.Match(KotlinParserAS) + } + { + p.SetState(462) + p.SimpleIdentifier() + } + + return localctx +} + +// ITopLevelObjectContext is an interface to support dynamic dispatch. +type ITopLevelObjectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTopLevelObjectContext differentiates from other interfaces. + IsTopLevelObjectContext() +} + +type TopLevelObjectContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTopLevelObjectContext() *TopLevelObjectContext { + var p = new(TopLevelObjectContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_topLevelObject + return p +} + +func (*TopLevelObjectContext) IsTopLevelObjectContext() {} + +func NewTopLevelObjectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TopLevelObjectContext { + var p = new(TopLevelObjectContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_topLevelObject + + return p +} + +func (s *TopLevelObjectContext) GetParser() antlr.Parser { return s.parser } + +func (s *TopLevelObjectContext) Declaration() IDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclarationContext) +} + +func (s *TopLevelObjectContext) Semis() ISemisContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemisContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISemisContext) +} + +func (s *TopLevelObjectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TopLevelObjectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TopLevelObjectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTopLevelObject(s) + } +} + +func (s *TopLevelObjectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTopLevelObject(s) + } +} + +func (p *KotlinParser) TopLevelObject() (localctx ITopLevelObjectContext) { + this := p + _ = this + + localctx = NewTopLevelObjectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, KotlinParserRULE_topLevelObject) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(464) + p.Declaration() + } + p.SetState(466) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserNL || _la == KotlinParserSEMICOLON { + { + p.SetState(465) + p.Semis() + } + + } + + return localctx +} + +// ITypeAliasContext is an interface to support dynamic dispatch. +type ITypeAliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeAliasContext differentiates from other interfaces. + IsTypeAliasContext() +} + +type TypeAliasContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeAliasContext() *TypeAliasContext { + var p = new(TypeAliasContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeAlias + return p +} + +func (*TypeAliasContext) IsTypeAliasContext() {} + +func NewTypeAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeAliasContext { + var p = new(TypeAliasContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeAlias + + return p +} + +func (s *TypeAliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeAliasContext) TYPE_ALIAS() antlr.TerminalNode { + return s.GetToken(KotlinParserTYPE_ALIAS, 0) +} + +func (s *TypeAliasContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *TypeAliasContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *TypeAliasContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *TypeAliasContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *TypeAliasContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeAliasContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeAliasContext) TypeParameters() ITypeParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeParametersContext) +} + +func (s *TypeAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeAlias(s) + } +} + +func (s *TypeAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeAlias(s) + } +} + +func (p *KotlinParser) TypeAlias() (localctx ITypeAliasContext) { + this := p + _ = this + + localctx = NewTypeAliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, KotlinParserRULE_typeAlias) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(469) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(468) + p.Modifiers() + } + + } + { + p.SetState(471) + p.Match(KotlinParserTYPE_ALIAS) + } + p.SetState(475) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(472) + p.Match(KotlinParserNL) + } + + p.SetState(477) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(478) + p.SimpleIdentifier() + } + p.SetState(486) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 { + p.SetState(482) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(479) + p.Match(KotlinParserNL) + } + + p.SetState(484) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(485) + p.TypeParameters() + } + + } + p.SetState(491) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(488) + p.Match(KotlinParserNL) + } + + p.SetState(493) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(494) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(498) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(495) + p.Match(KotlinParserNL) + } + + p.SetState(500) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(501) + p.Type_() + } + + return localctx +} + +// IDeclarationContext is an interface to support dynamic dispatch. +type IDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDeclarationContext differentiates from other interfaces. + IsDeclarationContext() +} + +type DeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclarationContext() *DeclarationContext { + var p = new(DeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_declaration + return p +} + +func (*DeclarationContext) IsDeclarationContext() {} + +func NewDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarationContext { + var p = new(DeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_declaration + + return p +} + +func (s *DeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeclarationContext) ClassDeclaration() IClassDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassDeclarationContext) +} + +func (s *DeclarationContext) ObjectDeclaration() IObjectDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObjectDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObjectDeclarationContext) +} + +func (s *DeclarationContext) FunctionDeclaration() IFunctionDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionDeclarationContext) +} + +func (s *DeclarationContext) PropertyDeclaration() IPropertyDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyDeclarationContext) +} + +func (s *DeclarationContext) TypeAlias() ITypeAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeAliasContext) +} + +func (s *DeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDeclaration(s) + } +} + +func (s *DeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDeclaration(s) + } +} + +func (p *KotlinParser) Declaration() (localctx IDeclarationContext) { + this := p + _ = this + + localctx = NewDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, KotlinParserRULE_declaration) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(508) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(503) + p.ClassDeclaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(504) + p.ObjectDeclaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(505) + p.FunctionDeclaration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(506) + p.PropertyDeclaration() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(507) + p.TypeAlias() + } + + } + + return localctx +} + +// IClassDeclarationContext is an interface to support dynamic dispatch. +type IClassDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassDeclarationContext differentiates from other interfaces. + IsClassDeclarationContext() +} + +type ClassDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassDeclarationContext() *ClassDeclarationContext { + var p = new(ClassDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classDeclaration + return p +} + +func (*ClassDeclarationContext) IsClassDeclarationContext() {} + +func NewClassDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassDeclarationContext { + var p = new(ClassDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classDeclaration + + return p +} + +func (s *ClassDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassDeclarationContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ClassDeclarationContext) CLASS() antlr.TerminalNode { + return s.GetToken(KotlinParserCLASS, 0) +} + +func (s *ClassDeclarationContext) INTERFACE() antlr.TerminalNode { + return s.GetToken(KotlinParserINTERFACE, 0) +} + +func (s *ClassDeclarationContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *ClassDeclarationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ClassDeclarationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ClassDeclarationContext) TypeParameters() ITypeParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeParametersContext) +} + +func (s *ClassDeclarationContext) PrimaryConstructor() IPrimaryConstructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryConstructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryConstructorContext) +} + +func (s *ClassDeclarationContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ClassDeclarationContext) DelegationSpecifiers() IDelegationSpecifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelegationSpecifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelegationSpecifiersContext) +} + +func (s *ClassDeclarationContext) TypeConstraints() ITypeConstraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeConstraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeConstraintsContext) +} + +func (s *ClassDeclarationContext) ClassBody() IClassBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassBodyContext) +} + +func (s *ClassDeclarationContext) EnumClassBody() IEnumClassBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnumClassBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnumClassBodyContext) +} + +func (s *ClassDeclarationContext) FUN() antlr.TerminalNode { + return s.GetToken(KotlinParserFUN, 0) +} + +func (s *ClassDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassDeclaration(s) + } +} + +func (s *ClassDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassDeclaration(s) + } +} + +func (p *KotlinParser) ClassDeclaration() (localctx IClassDeclarationContext) { + this := p + _ = this + + localctx = NewClassDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, KotlinParserRULE_classDeclaration) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(511) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(510) + p.Modifiers() + } + + } + p.SetState(524) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserCLASS: + { + p.SetState(513) + p.Match(KotlinParserCLASS) + } + + case KotlinParserINTERFACE, KotlinParserFUN: + p.SetState(521) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserFUN { + { + p.SetState(514) + p.Match(KotlinParserFUN) + } + p.SetState(518) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(515) + p.Match(KotlinParserNL) + } + + p.SetState(520) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(523) + p.Match(KotlinParserINTERFACE) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + p.SetState(529) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(526) + p.Match(KotlinParserNL) + } + + p.SetState(531) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(532) + p.SimpleIdentifier() + } + p.SetState(540) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 { + p.SetState(536) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(533) + p.Match(KotlinParserNL) + } + + p.SetState(538) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(539) + p.TypeParameters() + } + + } + p.SetState(549) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext()) == 1 { + p.SetState(545) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(542) + p.Match(KotlinParserNL) + } + + p.SetState(547) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(548) + p.PrimaryConstructor() + } + + } + p.SetState(565) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 38, p.GetParserRuleContext()) == 1 { + p.SetState(554) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(551) + p.Match(KotlinParserNL) + } + + p.SetState(556) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(557) + p.Match(KotlinParserCOLON) + } + p.SetState(561) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(558) + p.Match(KotlinParserNL) + } + + } + p.SetState(563) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) + } + { + p.SetState(564) + p.DelegationSpecifiers() + } + + } + p.SetState(574) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext()) == 1 { + p.SetState(570) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(567) + p.Match(KotlinParserNL) + } + + p.SetState(572) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(573) + p.TypeConstraints() + } + + } + p.SetState(590) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 { + p.SetState(579) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(576) + p.Match(KotlinParserNL) + } + + p.SetState(581) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(582) + p.ClassBody() + } + + } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 2 { + p.SetState(586) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(583) + p.Match(KotlinParserNL) + } + + p.SetState(588) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(589) + p.EnumClassBody() + } + + } + + return localctx +} + +// IPrimaryConstructorContext is an interface to support dynamic dispatch. +type IPrimaryConstructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPrimaryConstructorContext differentiates from other interfaces. + IsPrimaryConstructorContext() +} + +type PrimaryConstructorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimaryConstructorContext() *PrimaryConstructorContext { + var p = new(PrimaryConstructorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_primaryConstructor + return p +} + +func (*PrimaryConstructorContext) IsPrimaryConstructorContext() {} + +func NewPrimaryConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryConstructorContext { + var p = new(PrimaryConstructorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_primaryConstructor + + return p +} + +func (s *PrimaryConstructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimaryConstructorContext) ClassParameters() IClassParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassParametersContext) +} + +func (s *PrimaryConstructorContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(KotlinParserCONSTRUCTOR, 0) +} + +func (s *PrimaryConstructorContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *PrimaryConstructorContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *PrimaryConstructorContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *PrimaryConstructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryConstructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrimaryConstructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPrimaryConstructor(s) + } +} + +func (s *PrimaryConstructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPrimaryConstructor(s) + } +} + +func (p *KotlinParser) PrimaryConstructor() (localctx IPrimaryConstructorContext) { + this := p + _ = this + + localctx = NewPrimaryConstructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, KotlinParserRULE_primaryConstructor) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(602) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-80)) & ^0x3f) == 0 && ((int64(1)<<(_la-80))&63050394514751489) != 0 { + p.SetState(593) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(592) + p.Modifiers() + } + + } + { + p.SetState(595) + p.Match(KotlinParserCONSTRUCTOR) + } + p.SetState(599) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(596) + p.Match(KotlinParserNL) + } + + p.SetState(601) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(604) + p.ClassParameters() + } + + return localctx +} + +// IClassBodyContext is an interface to support dynamic dispatch. +type IClassBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassBodyContext differentiates from other interfaces. + IsClassBodyContext() +} + +type ClassBodyContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassBodyContext() *ClassBodyContext { + var p = new(ClassBodyContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classBody + return p +} + +func (*ClassBodyContext) IsClassBodyContext() {} + +func NewClassBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBodyContext { + var p = new(ClassBodyContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classBody + + return p +} + +func (s *ClassBodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassBodyContext) LCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserLCURL, 0) +} + +func (s *ClassBodyContext) ClassMemberDeclarations() IClassMemberDeclarationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassMemberDeclarationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassMemberDeclarationsContext) +} + +func (s *ClassBodyContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *ClassBodyContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ClassBodyContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ClassBodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassBodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassBody(s) + } +} + +func (s *ClassBodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassBody(s) + } +} + +func (p *KotlinParser) ClassBody() (localctx IClassBodyContext) { + this := p + _ = this + + localctx = NewClassBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, KotlinParserRULE_classBody) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(606) + p.Match(KotlinParserLCURL) + } + p.SetState(610) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 47, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(607) + p.Match(KotlinParserNL) + } + + } + p.SetState(612) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 47, p.GetParserRuleContext()) + } + { + p.SetState(613) + p.ClassMemberDeclarations() + } + p.SetState(617) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(614) + p.Match(KotlinParserNL) + } + + p.SetState(619) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(620) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// IClassParametersContext is an interface to support dynamic dispatch. +type IClassParametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassParametersContext differentiates from other interfaces. + IsClassParametersContext() +} + +type ClassParametersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassParametersContext() *ClassParametersContext { + var p = new(ClassParametersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classParameters + return p +} + +func (*ClassParametersContext) IsClassParametersContext() {} + +func NewClassParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassParametersContext { + var p = new(ClassParametersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classParameters + + return p +} + +func (s *ClassParametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassParametersContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ClassParametersContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ClassParametersContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ClassParametersContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ClassParametersContext) AllClassParameter() []IClassParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassParameterContext); ok { + len++ + } + } + + tst := make([]IClassParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassParameterContext); ok { + tst[i] = t.(IClassParameterContext) + i++ + } + } + + return tst +} + +func (s *ClassParametersContext) ClassParameter(i int) IClassParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassParameterContext) +} + +func (s *ClassParametersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *ClassParametersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *ClassParametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassParametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassParameters(s) + } +} + +func (s *ClassParametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassParameters(s) + } +} + +func (p *KotlinParser) ClassParameters() (localctx IClassParametersContext) { + this := p + _ = this + + localctx = NewClassParametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, KotlinParserRULE_classParameters) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(622) + p.Match(KotlinParserLPAREN) + } + p.SetState(626) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(623) + p.Match(KotlinParserNL) + } + + } + p.SetState(628) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext()) + } + p.SetState(658) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 { + { + p.SetState(629) + p.ClassParameter() + } + p.SetState(646) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(633) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(630) + p.Match(KotlinParserNL) + } + + p.SetState(635) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(636) + p.Match(KotlinParserCOMMA) + } + p.SetState(640) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(637) + p.Match(KotlinParserNL) + } + + } + p.SetState(642) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext()) + } + { + p.SetState(643) + p.ClassParameter() + } + + } + p.SetState(648) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) + } + p.SetState(656) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 54, p.GetParserRuleContext()) == 1 { + p.SetState(652) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(649) + p.Match(KotlinParserNL) + } + + p.SetState(654) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(655) + p.Match(KotlinParserCOMMA) + } + + } + + } + p.SetState(663) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(660) + p.Match(KotlinParserNL) + } + + p.SetState(665) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(666) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IClassParameterContext is an interface to support dynamic dispatch. +type IClassParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassParameterContext differentiates from other interfaces. + IsClassParameterContext() +} + +type ClassParameterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassParameterContext() *ClassParameterContext { + var p = new(ClassParameterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classParameter + return p +} + +func (*ClassParameterContext) IsClassParameterContext() {} + +func NewClassParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassParameterContext { + var p = new(ClassParameterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classParameter + + return p +} + +func (s *ClassParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassParameterContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ClassParameterContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ClassParameterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *ClassParameterContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *ClassParameterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ClassParameterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ClassParameterContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *ClassParameterContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ClassParameterContext) VAL() antlr.TerminalNode { + return s.GetToken(KotlinParserVAL, 0) +} + +func (s *ClassParameterContext) VAR() antlr.TerminalNode { + return s.GetToken(KotlinParserVAR, 0) +} + +func (s *ClassParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassParameter(s) + } +} + +func (s *ClassParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassParameter(s) + } +} + +func (p *KotlinParser) ClassParameter() (localctx IClassParameterContext) { + this := p + _ = this + + localctx = NewClassParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, KotlinParserRULE_classParameter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(669) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 { + { + p.SetState(668) + p.Modifiers() + } + + } + p.SetState(672) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserVAL || _la == KotlinParserVAR { + { + p.SetState(671) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserVAL || _la == KotlinParserVAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(677) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(674) + p.Match(KotlinParserNL) + } + + p.SetState(679) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(680) + p.SimpleIdentifier() + } + { + p.SetState(681) + p.Match(KotlinParserCOLON) + } + p.SetState(685) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(682) + p.Match(KotlinParserNL) + } + + p.SetState(687) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(688) + p.Type_() + } + p.SetState(703) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 { + p.SetState(692) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(689) + p.Match(KotlinParserNL) + } + + p.SetState(694) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(695) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(699) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(696) + p.Match(KotlinParserNL) + } + + p.SetState(701) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(702) + p.Expression() + } + + } + + return localctx +} + +// IDelegationSpecifiersContext is an interface to support dynamic dispatch. +type IDelegationSpecifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDelegationSpecifiersContext differentiates from other interfaces. + IsDelegationSpecifiersContext() +} + +type DelegationSpecifiersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelegationSpecifiersContext() *DelegationSpecifiersContext { + var p = new(DelegationSpecifiersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_delegationSpecifiers + return p +} + +func (*DelegationSpecifiersContext) IsDelegationSpecifiersContext() {} + +func NewDelegationSpecifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DelegationSpecifiersContext { + var p = new(DelegationSpecifiersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_delegationSpecifiers + + return p +} + +func (s *DelegationSpecifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *DelegationSpecifiersContext) AllAnnotatedDelegationSpecifier() []IAnnotatedDelegationSpecifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotatedDelegationSpecifierContext); ok { + len++ + } + } + + tst := make([]IAnnotatedDelegationSpecifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotatedDelegationSpecifierContext); ok { + tst[i] = t.(IAnnotatedDelegationSpecifierContext) + i++ + } + } + + return tst +} + +func (s *DelegationSpecifiersContext) AnnotatedDelegationSpecifier(i int) IAnnotatedDelegationSpecifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotatedDelegationSpecifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotatedDelegationSpecifierContext) +} + +func (s *DelegationSpecifiersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *DelegationSpecifiersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *DelegationSpecifiersContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *DelegationSpecifiersContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *DelegationSpecifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DelegationSpecifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DelegationSpecifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDelegationSpecifiers(s) + } +} + +func (s *DelegationSpecifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDelegationSpecifiers(s) + } +} + +func (p *KotlinParser) DelegationSpecifiers() (localctx IDelegationSpecifiersContext) { + this := p + _ = this + + localctx = NewDelegationSpecifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, KotlinParserRULE_delegationSpecifiers) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(705) + p.AnnotatedDelegationSpecifier() + } + p.SetState(722) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(709) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(706) + p.Match(KotlinParserNL) + } + + p.SetState(711) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(712) + p.Match(KotlinParserCOMMA) + } + p.SetState(716) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 65, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(713) + p.Match(KotlinParserNL) + } + + } + p.SetState(718) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 65, p.GetParserRuleContext()) + } + { + p.SetState(719) + p.AnnotatedDelegationSpecifier() + } + + } + p.SetState(724) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext()) + } + + return localctx +} + +// IDelegationSpecifierContext is an interface to support dynamic dispatch. +type IDelegationSpecifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDelegationSpecifierContext differentiates from other interfaces. + IsDelegationSpecifierContext() +} + +type DelegationSpecifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelegationSpecifierContext() *DelegationSpecifierContext { + var p = new(DelegationSpecifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_delegationSpecifier + return p +} + +func (*DelegationSpecifierContext) IsDelegationSpecifierContext() {} + +func NewDelegationSpecifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DelegationSpecifierContext { + var p = new(DelegationSpecifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_delegationSpecifier + + return p +} + +func (s *DelegationSpecifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *DelegationSpecifierContext) ConstructorInvocation() IConstructorInvocationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructorInvocationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructorInvocationContext) +} + +func (s *DelegationSpecifierContext) ExplicitDelegation() IExplicitDelegationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplicitDelegationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplicitDelegationContext) +} + +func (s *DelegationSpecifierContext) UserType() IUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *DelegationSpecifierContext) FunctionType() IFunctionTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionTypeContext) +} + +func (s *DelegationSpecifierContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(KotlinParserSUSPEND, 0) +} + +func (s *DelegationSpecifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *DelegationSpecifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *DelegationSpecifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DelegationSpecifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DelegationSpecifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDelegationSpecifier(s) + } +} + +func (s *DelegationSpecifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDelegationSpecifier(s) + } +} + +func (p *KotlinParser) DelegationSpecifier() (localctx IDelegationSpecifierContext) { + this := p + _ = this + + localctx = NewDelegationSpecifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, KotlinParserRULE_delegationSpecifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(737) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(725) + p.ConstructorInvocation() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(726) + p.ExplicitDelegation() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(727) + p.UserType() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(728) + p.FunctionType() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(729) + p.Match(KotlinParserSUSPEND) + } + p.SetState(733) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(730) + p.Match(KotlinParserNL) + } + + p.SetState(735) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(736) + p.FunctionType() + } + + } + + return localctx +} + +// IConstructorInvocationContext is an interface to support dynamic dispatch. +type IConstructorInvocationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsConstructorInvocationContext differentiates from other interfaces. + IsConstructorInvocationContext() +} + +type ConstructorInvocationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstructorInvocationContext() *ConstructorInvocationContext { + var p = new(ConstructorInvocationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_constructorInvocation + return p +} + +func (*ConstructorInvocationContext) IsConstructorInvocationContext() {} + +func NewConstructorInvocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstructorInvocationContext { + var p = new(ConstructorInvocationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_constructorInvocation + + return p +} + +func (s *ConstructorInvocationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstructorInvocationContext) UserType() IUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *ConstructorInvocationContext) ValueArguments() IValueArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueArgumentsContext) +} + +func (s *ConstructorInvocationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstructorInvocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstructorInvocationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterConstructorInvocation(s) + } +} + +func (s *ConstructorInvocationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitConstructorInvocation(s) + } +} + +func (p *KotlinParser) ConstructorInvocation() (localctx IConstructorInvocationContext) { + this := p + _ = this + + localctx = NewConstructorInvocationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, KotlinParserRULE_constructorInvocation) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(739) + p.UserType() + } + { + p.SetState(740) + p.ValueArguments() + } + + return localctx +} + +// IAnnotatedDelegationSpecifierContext is an interface to support dynamic dispatch. +type IAnnotatedDelegationSpecifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAnnotatedDelegationSpecifierContext differentiates from other interfaces. + IsAnnotatedDelegationSpecifierContext() +} + +type AnnotatedDelegationSpecifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotatedDelegationSpecifierContext() *AnnotatedDelegationSpecifierContext { + var p = new(AnnotatedDelegationSpecifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_annotatedDelegationSpecifier + return p +} + +func (*AnnotatedDelegationSpecifierContext) IsAnnotatedDelegationSpecifierContext() {} + +func NewAnnotatedDelegationSpecifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotatedDelegationSpecifierContext { + var p = new(AnnotatedDelegationSpecifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_annotatedDelegationSpecifier + + return p +} + +func (s *AnnotatedDelegationSpecifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnnotatedDelegationSpecifierContext) DelegationSpecifier() IDelegationSpecifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelegationSpecifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelegationSpecifierContext) +} + +func (s *AnnotatedDelegationSpecifierContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *AnnotatedDelegationSpecifierContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *AnnotatedDelegationSpecifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AnnotatedDelegationSpecifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AnnotatedDelegationSpecifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnnotatedDelegationSpecifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnnotatedDelegationSpecifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAnnotatedDelegationSpecifier(s) + } +} + +func (s *AnnotatedDelegationSpecifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAnnotatedDelegationSpecifier(s) + } +} + +func (p *KotlinParser) AnnotatedDelegationSpecifier() (localctx IAnnotatedDelegationSpecifierContext) { + this := p + _ = this + + localctx = NewAnnotatedDelegationSpecifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, KotlinParserRULE_annotatedDelegationSpecifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(745) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(742) + p.Annotation() + } + + } + p.SetState(747) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext()) + } + p.SetState(751) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(748) + p.Match(KotlinParserNL) + } + + p.SetState(753) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(754) + p.DelegationSpecifier() + } + + return localctx +} + +// IExplicitDelegationContext is an interface to support dynamic dispatch. +type IExplicitDelegationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsExplicitDelegationContext differentiates from other interfaces. + IsExplicitDelegationContext() +} + +type ExplicitDelegationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplicitDelegationContext() *ExplicitDelegationContext { + var p = new(ExplicitDelegationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_explicitDelegation + return p +} + +func (*ExplicitDelegationContext) IsExplicitDelegationContext() {} + +func NewExplicitDelegationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplicitDelegationContext { + var p = new(ExplicitDelegationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_explicitDelegation + + return p +} + +func (s *ExplicitDelegationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExplicitDelegationContext) BY() antlr.TerminalNode { + return s.GetToken(KotlinParserBY, 0) +} + +func (s *ExplicitDelegationContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExplicitDelegationContext) UserType() IUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *ExplicitDelegationContext) FunctionType() IFunctionTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionTypeContext) +} + +func (s *ExplicitDelegationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ExplicitDelegationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ExplicitDelegationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExplicitDelegationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExplicitDelegationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterExplicitDelegation(s) + } +} + +func (s *ExplicitDelegationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitExplicitDelegation(s) + } +} + +func (p *KotlinParser) ExplicitDelegation() (localctx IExplicitDelegationContext) { + this := p + _ = this + + localctx = NewExplicitDelegationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, KotlinParserRULE_explicitDelegation) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(758) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 71, p.GetParserRuleContext()) { + case 1: + { + p.SetState(756) + p.UserType() + } + + case 2: + { + p.SetState(757) + p.FunctionType() + } + + } + p.SetState(763) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(760) + p.Match(KotlinParserNL) + } + + p.SetState(765) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(766) + p.Match(KotlinParserBY) + } + p.SetState(770) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(767) + p.Match(KotlinParserNL) + } + + p.SetState(772) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(773) + p.Expression() + } + + return localctx +} + +// ITypeParametersContext is an interface to support dynamic dispatch. +type ITypeParametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeParametersContext differentiates from other interfaces. + IsTypeParametersContext() +} + +type TypeParametersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeParametersContext() *TypeParametersContext { + var p = new(TypeParametersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeParameters + return p +} + +func (*TypeParametersContext) IsTypeParametersContext() {} + +func NewTypeParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParametersContext { + var p = new(TypeParametersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeParameters + + return p +} + +func (s *TypeParametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeParametersContext) LANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserLANGLE, 0) +} + +func (s *TypeParametersContext) AllTypeParameter() []ITypeParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeParameterContext); ok { + len++ + } + } + + tst := make([]ITypeParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeParameterContext); ok { + tst[i] = t.(ITypeParameterContext) + i++ + } + } + + return tst +} + +func (s *TypeParametersContext) TypeParameter(i int) ITypeParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeParameterContext) +} + +func (s *TypeParametersContext) RANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserRANGLE, 0) +} + +func (s *TypeParametersContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeParametersContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeParametersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *TypeParametersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *TypeParametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeParametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeParameters(s) + } +} + +func (s *TypeParametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeParameters(s) + } +} + +func (p *KotlinParser) TypeParameters() (localctx ITypeParametersContext) { + this := p + _ = this + + localctx = NewTypeParametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, KotlinParserRULE_typeParameters) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(775) + p.Match(KotlinParserLANGLE) + } + p.SetState(779) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(776) + p.Match(KotlinParserNL) + } + + } + p.SetState(781) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext()) + } + { + p.SetState(782) + p.TypeParameter() + } + p.SetState(799) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(786) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(783) + p.Match(KotlinParserNL) + } + + p.SetState(788) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(789) + p.Match(KotlinParserCOMMA) + } + p.SetState(793) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(790) + p.Match(KotlinParserNL) + } + + } + p.SetState(795) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) + } + { + p.SetState(796) + p.TypeParameter() + } + + } + p.SetState(801) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext()) + } + p.SetState(809) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 { + p.SetState(805) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(802) + p.Match(KotlinParserNL) + } + + p.SetState(807) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(808) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(814) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(811) + p.Match(KotlinParserNL) + } + + p.SetState(816) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(817) + p.Match(KotlinParserRANGLE) + } + + return localctx +} + +// ITypeParameterContext is an interface to support dynamic dispatch. +type ITypeParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeParameterContext differentiates from other interfaces. + IsTypeParameterContext() +} + +type TypeParameterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeParameterContext() *TypeParameterContext { + var p = new(TypeParameterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeParameter + return p +} + +func (*TypeParameterContext) IsTypeParameterContext() {} + +func NewTypeParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParameterContext { + var p = new(TypeParameterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeParameter + + return p +} + +func (s *TypeParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeParameterContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *TypeParameterContext) TypeParameterModifiers() ITypeParameterModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParameterModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeParameterModifiersContext) +} + +func (s *TypeParameterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeParameterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeParameterContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *TypeParameterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *TypeParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeParameter(s) + } +} + +func (s *TypeParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeParameter(s) + } +} + +func (p *KotlinParser) TypeParameter() (localctx ITypeParameterContext) { + this := p + _ = this + + localctx = NewTypeParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, KotlinParserRULE_typeParameter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(820) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 { + { + p.SetState(819) + p.TypeParameterModifiers() + } + + } + p.SetState(825) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(822) + p.Match(KotlinParserNL) + } + + p.SetState(827) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(828) + p.SimpleIdentifier() + } + p.SetState(843) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 { + p.SetState(832) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(829) + p.Match(KotlinParserNL) + } + + p.SetState(834) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(835) + p.Match(KotlinParserCOLON) + } + p.SetState(839) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(836) + p.Match(KotlinParserNL) + } + + p.SetState(841) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(842) + p.Type_() + } + + } + + return localctx +} + +// ITypeConstraintsContext is an interface to support dynamic dispatch. +type ITypeConstraintsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeConstraintsContext differentiates from other interfaces. + IsTypeConstraintsContext() +} + +type TypeConstraintsContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeConstraintsContext() *TypeConstraintsContext { + var p = new(TypeConstraintsContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeConstraints + return p +} + +func (*TypeConstraintsContext) IsTypeConstraintsContext() {} + +func NewTypeConstraintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeConstraintsContext { + var p = new(TypeConstraintsContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeConstraints + + return p +} + +func (s *TypeConstraintsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeConstraintsContext) WHERE() antlr.TerminalNode { + return s.GetToken(KotlinParserWHERE, 0) +} + +func (s *TypeConstraintsContext) AllTypeConstraint() []ITypeConstraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeConstraintContext); ok { + len++ + } + } + + tst := make([]ITypeConstraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeConstraintContext); ok { + tst[i] = t.(ITypeConstraintContext) + i++ + } + } + + return tst +} + +func (s *TypeConstraintsContext) TypeConstraint(i int) ITypeConstraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeConstraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeConstraintContext) +} + +func (s *TypeConstraintsContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeConstraintsContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeConstraintsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *TypeConstraintsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *TypeConstraintsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeConstraintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeConstraintsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeConstraints(s) + } +} + +func (s *TypeConstraintsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeConstraints(s) + } +} + +func (p *KotlinParser) TypeConstraints() (localctx ITypeConstraintsContext) { + this := p + _ = this + + localctx = NewTypeConstraintsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, KotlinParserRULE_typeConstraints) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(845) + p.Match(KotlinParserWHERE) + } + p.SetState(849) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(846) + p.Match(KotlinParserNL) + } + + p.SetState(851) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(852) + p.TypeConstraint() + } + p.SetState(869) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(856) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(853) + p.Match(KotlinParserNL) + } + + p.SetState(858) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(859) + p.Match(KotlinParserCOMMA) + } + p.SetState(863) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(860) + p.Match(KotlinParserNL) + } + + p.SetState(865) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(866) + p.TypeConstraint() + } + + } + p.SetState(871) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) + } + + return localctx +} + +// ITypeConstraintContext is an interface to support dynamic dispatch. +type ITypeConstraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeConstraintContext differentiates from other interfaces. + IsTypeConstraintContext() +} + +type TypeConstraintContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeConstraintContext() *TypeConstraintContext { + var p = new(TypeConstraintContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeConstraint + return p +} + +func (*TypeConstraintContext) IsTypeConstraintContext() {} + +func NewTypeConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeConstraintContext { + var p = new(TypeConstraintContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeConstraint + + return p +} + +func (s *TypeConstraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeConstraintContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *TypeConstraintContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *TypeConstraintContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *TypeConstraintContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *TypeConstraintContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *TypeConstraintContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeConstraintContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeConstraint(s) + } +} + +func (s *TypeConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeConstraint(s) + } +} + +func (p *KotlinParser) TypeConstraint() (localctx ITypeConstraintContext) { + this := p + _ = this + + localctx = NewTypeConstraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, KotlinParserRULE_typeConstraint) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(875) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS { + { + p.SetState(872) + p.Annotation() + } + + p.SetState(877) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(878) + p.SimpleIdentifier() + } + p.SetState(882) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(879) + p.Match(KotlinParserNL) + } + + p.SetState(884) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(885) + p.Match(KotlinParserCOLON) + } + p.SetState(889) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(886) + p.Match(KotlinParserNL) + } + + p.SetState(891) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(892) + p.Type_() + } + + return localctx +} + +// IClassMemberDeclarationsContext is an interface to support dynamic dispatch. +type IClassMemberDeclarationsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassMemberDeclarationsContext differentiates from other interfaces. + IsClassMemberDeclarationsContext() +} + +type ClassMemberDeclarationsContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassMemberDeclarationsContext() *ClassMemberDeclarationsContext { + var p = new(ClassMemberDeclarationsContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classMemberDeclarations + return p +} + +func (*ClassMemberDeclarationsContext) IsClassMemberDeclarationsContext() {} + +func NewClassMemberDeclarationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMemberDeclarationsContext { + var p = new(ClassMemberDeclarationsContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classMemberDeclarations + + return p +} + +func (s *ClassMemberDeclarationsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassMemberDeclarationsContext) AllClassMemberDeclaration() []IClassMemberDeclarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassMemberDeclarationContext); ok { + len++ + } + } + + tst := make([]IClassMemberDeclarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassMemberDeclarationContext); ok { + tst[i] = t.(IClassMemberDeclarationContext) + i++ + } + } + + return tst +} + +func (s *ClassMemberDeclarationsContext) ClassMemberDeclaration(i int) IClassMemberDeclarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassMemberDeclarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassMemberDeclarationContext) +} + +func (s *ClassMemberDeclarationsContext) AllSemis() []ISemisContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISemisContext); ok { + len++ + } + } + + tst := make([]ISemisContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISemisContext); ok { + tst[i] = t.(ISemisContext) + i++ + } + } + + return tst +} + +func (s *ClassMemberDeclarationsContext) Semis(i int) ISemisContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemisContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISemisContext) +} + +func (s *ClassMemberDeclarationsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassMemberDeclarationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassMemberDeclarationsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassMemberDeclarations(s) + } +} + +func (s *ClassMemberDeclarationsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassMemberDeclarations(s) + } +} + +func (p *KotlinParser) ClassMemberDeclarations() (localctx IClassMemberDeclarationsContext) { + this := p + _ = this + + localctx = NewClassMemberDeclarationsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, KotlinParserRULE_classMemberDeclarations) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(900) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&8070450497888192255) != 0 { + { + p.SetState(894) + p.ClassMemberDeclaration() + } + p.SetState(896) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 93, p.GetParserRuleContext()) == 1 { + { + p.SetState(895) + p.Semis() + } + + } + + p.SetState(902) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + return localctx +} + +// IClassMemberDeclarationContext is an interface to support dynamic dispatch. +type IClassMemberDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassMemberDeclarationContext differentiates from other interfaces. + IsClassMemberDeclarationContext() +} + +type ClassMemberDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassMemberDeclarationContext() *ClassMemberDeclarationContext { + var p = new(ClassMemberDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classMemberDeclaration + return p +} + +func (*ClassMemberDeclarationContext) IsClassMemberDeclarationContext() {} + +func NewClassMemberDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMemberDeclarationContext { + var p = new(ClassMemberDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classMemberDeclaration + + return p +} + +func (s *ClassMemberDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassMemberDeclarationContext) Declaration() IDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclarationContext) +} + +func (s *ClassMemberDeclarationContext) CompanionObject() ICompanionObjectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompanionObjectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompanionObjectContext) +} + +func (s *ClassMemberDeclarationContext) AnonymousInitializer() IAnonymousInitializerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnonymousInitializerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnonymousInitializerContext) +} + +func (s *ClassMemberDeclarationContext) SecondaryConstructor() ISecondaryConstructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecondaryConstructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecondaryConstructorContext) +} + +func (s *ClassMemberDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassMemberDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassMemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassMemberDeclaration(s) + } +} + +func (s *ClassMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassMemberDeclaration(s) + } +} + +func (p *KotlinParser) ClassMemberDeclaration() (localctx IClassMemberDeclarationContext) { + this := p + _ = this + + localctx = NewClassMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, KotlinParserRULE_classMemberDeclaration) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(907) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 95, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(903) + p.Declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(904) + p.CompanionObject() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(905) + p.AnonymousInitializer() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(906) + p.SecondaryConstructor() + } + + } + + return localctx +} + +// IAnonymousInitializerContext is an interface to support dynamic dispatch. +type IAnonymousInitializerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAnonymousInitializerContext differentiates from other interfaces. + IsAnonymousInitializerContext() +} + +type AnonymousInitializerContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnonymousInitializerContext() *AnonymousInitializerContext { + var p = new(AnonymousInitializerContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_anonymousInitializer + return p +} + +func (*AnonymousInitializerContext) IsAnonymousInitializerContext() {} + +func NewAnonymousInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousInitializerContext { + var p = new(AnonymousInitializerContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_anonymousInitializer + + return p +} + +func (s *AnonymousInitializerContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnonymousInitializerContext) INIT() antlr.TerminalNode { + return s.GetToken(KotlinParserINIT, 0) +} + +func (s *AnonymousInitializerContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *AnonymousInitializerContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AnonymousInitializerContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AnonymousInitializerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnonymousInitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnonymousInitializerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAnonymousInitializer(s) + } +} + +func (s *AnonymousInitializerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAnonymousInitializer(s) + } +} + +func (p *KotlinParser) AnonymousInitializer() (localctx IAnonymousInitializerContext) { + this := p + _ = this + + localctx = NewAnonymousInitializerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, KotlinParserRULE_anonymousInitializer) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(909) + p.Match(KotlinParserINIT) + } + p.SetState(913) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(910) + p.Match(KotlinParserNL) + } + + p.SetState(915) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(916) + p.Block() + } + + return localctx +} + +// ICompanionObjectContext is an interface to support dynamic dispatch. +type ICompanionObjectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsCompanionObjectContext differentiates from other interfaces. + IsCompanionObjectContext() +} + +type CompanionObjectContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompanionObjectContext() *CompanionObjectContext { + var p = new(CompanionObjectContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_companionObject + return p +} + +func (*CompanionObjectContext) IsCompanionObjectContext() {} + +func NewCompanionObjectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompanionObjectContext { + var p = new(CompanionObjectContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_companionObject + + return p +} + +func (s *CompanionObjectContext) GetParser() antlr.Parser { return s.parser } + +func (s *CompanionObjectContext) COMPANION() antlr.TerminalNode { + return s.GetToken(KotlinParserCOMPANION, 0) +} + +func (s *CompanionObjectContext) OBJECT() antlr.TerminalNode { + return s.GetToken(KotlinParserOBJECT, 0) +} + +func (s *CompanionObjectContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *CompanionObjectContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *CompanionObjectContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *CompanionObjectContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *CompanionObjectContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *CompanionObjectContext) DelegationSpecifiers() IDelegationSpecifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelegationSpecifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelegationSpecifiersContext) +} + +func (s *CompanionObjectContext) ClassBody() IClassBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassBodyContext) +} + +func (s *CompanionObjectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CompanionObjectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CompanionObjectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterCompanionObject(s) + } +} + +func (s *CompanionObjectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitCompanionObject(s) + } +} + +func (p *KotlinParser) CompanionObject() (localctx ICompanionObjectContext) { + this := p + _ = this + + localctx = NewCompanionObjectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, KotlinParserRULE_companionObject) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(919) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(918) + p.Modifiers() + } + + } + { + p.SetState(921) + p.Match(KotlinParserCOMPANION) + } + p.SetState(925) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(922) + p.Match(KotlinParserNL) + } + + p.SetState(927) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(928) + p.Match(KotlinParserOBJECT) + } + p.SetState(936) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 { + p.SetState(932) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(929) + p.Match(KotlinParserNL) + } + + p.SetState(934) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(935) + p.SimpleIdentifier() + } + + } + p.SetState(952) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 { + p.SetState(941) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(938) + p.Match(KotlinParserNL) + } + + p.SetState(943) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(944) + p.Match(KotlinParserCOLON) + } + p.SetState(948) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 102, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(945) + p.Match(KotlinParserNL) + } + + } + p.SetState(950) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 102, p.GetParserRuleContext()) + } + { + p.SetState(951) + p.DelegationSpecifiers() + } + + } + p.SetState(961) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) == 1 { + p.SetState(957) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(954) + p.Match(KotlinParserNL) + } + + p.SetState(959) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(960) + p.ClassBody() + } + + } + + return localctx +} + +// IFunctionValueParametersContext is an interface to support dynamic dispatch. +type IFunctionValueParametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionValueParametersContext differentiates from other interfaces. + IsFunctionValueParametersContext() +} + +type FunctionValueParametersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionValueParametersContext() *FunctionValueParametersContext { + var p = new(FunctionValueParametersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionValueParameters + return p +} + +func (*FunctionValueParametersContext) IsFunctionValueParametersContext() {} + +func NewFunctionValueParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionValueParametersContext { + var p = new(FunctionValueParametersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionValueParameters + + return p +} + +func (s *FunctionValueParametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionValueParametersContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *FunctionValueParametersContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *FunctionValueParametersContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionValueParametersContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionValueParametersContext) AllFunctionValueParameter() []IFunctionValueParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionValueParameterContext); ok { + len++ + } + } + + tst := make([]IFunctionValueParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionValueParameterContext); ok { + tst[i] = t.(IFunctionValueParameterContext) + i++ + } + } + + return tst +} + +func (s *FunctionValueParametersContext) FunctionValueParameter(i int) IFunctionValueParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionValueParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionValueParameterContext) +} + +func (s *FunctionValueParametersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *FunctionValueParametersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *FunctionValueParametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionValueParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionValueParametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionValueParameters(s) + } +} + +func (s *FunctionValueParametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionValueParameters(s) + } +} + +func (p *KotlinParser) FunctionValueParameters() (localctx IFunctionValueParametersContext) { + this := p + _ = this + + localctx = NewFunctionValueParametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, KotlinParserRULE_functionValueParameters) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(963) + p.Match(KotlinParserLPAREN) + } + p.SetState(967) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(964) + p.Match(KotlinParserNL) + } + + } + p.SetState(969) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext()) + } + p.SetState(999) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64((_la-40)) & ^0x3f) == 0 && ((int64(1)<<(_la-40))&13668035483140101) != 0 || (int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&2200096997375) != 0 { + { + p.SetState(970) + p.FunctionValueParameter() + } + p.SetState(987) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 109, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(974) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(971) + p.Match(KotlinParserNL) + } + + p.SetState(976) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(977) + p.Match(KotlinParserCOMMA) + } + p.SetState(981) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(978) + p.Match(KotlinParserNL) + } + + p.SetState(983) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(984) + p.FunctionValueParameter() + } + + } + p.SetState(989) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 109, p.GetParserRuleContext()) + } + p.SetState(997) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 { + p.SetState(993) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(990) + p.Match(KotlinParserNL) + } + + p.SetState(995) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(996) + p.Match(KotlinParserCOMMA) + } + + } + + } + p.SetState(1004) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1001) + p.Match(KotlinParserNL) + } + + p.SetState(1006) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1007) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IFunctionValueParameterContext is an interface to support dynamic dispatch. +type IFunctionValueParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionValueParameterContext differentiates from other interfaces. + IsFunctionValueParameterContext() +} + +type FunctionValueParameterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionValueParameterContext() *FunctionValueParameterContext { + var p = new(FunctionValueParameterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionValueParameter + return p +} + +func (*FunctionValueParameterContext) IsFunctionValueParameterContext() {} + +func NewFunctionValueParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionValueParameterContext { + var p = new(FunctionValueParameterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionValueParameter + + return p +} + +func (s *FunctionValueParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionValueParameterContext) Parameter() IParameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *FunctionValueParameterContext) ParameterModifiers() IParameterModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterModifiersContext) +} + +func (s *FunctionValueParameterContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *FunctionValueParameterContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FunctionValueParameterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionValueParameterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionValueParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionValueParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionValueParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionValueParameter(s) + } +} + +func (s *FunctionValueParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionValueParameter(s) + } +} + +func (p *KotlinParser) FunctionValueParameter() (localctx IFunctionValueParameterContext) { + this := p + _ = this + + localctx = NewFunctionValueParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, KotlinParserRULE_functionValueParameter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1010) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 114, p.GetParserRuleContext()) == 1 { + { + p.SetState(1009) + p.ParameterModifiers() + } + + } + { + p.SetState(1012) + p.Parameter() + } + p.SetState(1027) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext()) == 1 { + p.SetState(1016) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1013) + p.Match(KotlinParserNL) + } + + p.SetState(1018) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1019) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(1023) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1020) + p.Match(KotlinParserNL) + } + + p.SetState(1025) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1026) + p.Expression() + } + + } + + return localctx +} + +// IFunctionDeclarationContext is an interface to support dynamic dispatch. +type IFunctionDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionDeclarationContext differentiates from other interfaces. + IsFunctionDeclarationContext() +} + +type FunctionDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionDeclarationContext() *FunctionDeclarationContext { + var p = new(FunctionDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionDeclaration + return p +} + +func (*FunctionDeclarationContext) IsFunctionDeclarationContext() {} + +func NewFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDeclarationContext { + var p = new(FunctionDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionDeclaration + + return p +} + +func (s *FunctionDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionDeclarationContext) FUN() antlr.TerminalNode { + return s.GetToken(KotlinParserFUN, 0) +} + +func (s *FunctionDeclarationContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *FunctionDeclarationContext) FunctionValueParameters() IFunctionValueParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionValueParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionValueParametersContext) +} + +func (s *FunctionDeclarationContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *FunctionDeclarationContext) TypeParameters() ITypeParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeParametersContext) +} + +func (s *FunctionDeclarationContext) ReceiverType() IReceiverTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReceiverTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReceiverTypeContext) +} + +func (s *FunctionDeclarationContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *FunctionDeclarationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionDeclarationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionDeclarationContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *FunctionDeclarationContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *FunctionDeclarationContext) TypeConstraints() ITypeConstraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeConstraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeConstraintsContext) +} + +func (s *FunctionDeclarationContext) FunctionBody() IFunctionBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionBodyContext) +} + +func (s *FunctionDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionDeclaration(s) + } +} + +func (s *FunctionDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionDeclaration(s) + } +} + +func (p *KotlinParser) FunctionDeclaration() (localctx IFunctionDeclarationContext) { + this := p + _ = this + + localctx = NewFunctionDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, KotlinParserRULE_functionDeclaration) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1030) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(1029) + p.Modifiers() + } + + } + { + p.SetState(1032) + p.Match(KotlinParserFUN) + } + p.SetState(1040) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 120, p.GetParserRuleContext()) == 1 { + p.SetState(1036) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1033) + p.Match(KotlinParserNL) + } + + p.SetState(1038) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1039) + p.TypeParameters() + } + + } + p.SetState(1057) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 { + p.SetState(1045) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1042) + p.Match(KotlinParserNL) + } + + p.SetState(1047) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1048) + p.ReceiverType() + } + p.SetState(1052) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1049) + p.Match(KotlinParserNL) + } + + p.SetState(1054) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1055) + p.Match(KotlinParserDOT) + } + + } + p.SetState(1062) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1059) + p.Match(KotlinParserNL) + } + + p.SetState(1064) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1065) + p.SimpleIdentifier() + } + p.SetState(1069) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1066) + p.Match(KotlinParserNL) + } + + p.SetState(1071) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1072) + p.FunctionValueParameters() + } + p.SetState(1087) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 128, p.GetParserRuleContext()) == 1 { + p.SetState(1076) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1073) + p.Match(KotlinParserNL) + } + + p.SetState(1078) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1079) + p.Match(KotlinParserCOLON) + } + p.SetState(1083) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1080) + p.Match(KotlinParserNL) + } + + p.SetState(1085) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1086) + p.Type_() + } + + } + p.SetState(1096) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 130, p.GetParserRuleContext()) == 1 { + p.SetState(1092) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1089) + p.Match(KotlinParserNL) + } + + p.SetState(1094) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1095) + p.TypeConstraints() + } + + } + p.SetState(1105) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 132, p.GetParserRuleContext()) == 1 { + p.SetState(1101) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1098) + p.Match(KotlinParserNL) + } + + p.SetState(1103) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1104) + p.FunctionBody() + } + + } + + return localctx +} + +// IFunctionBodyContext is an interface to support dynamic dispatch. +type IFunctionBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionBodyContext differentiates from other interfaces. + IsFunctionBodyContext() +} + +type FunctionBodyContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionBodyContext() *FunctionBodyContext { + var p = new(FunctionBodyContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionBody + return p +} + +func (*FunctionBodyContext) IsFunctionBodyContext() {} + +func NewFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionBodyContext { + var p = new(FunctionBodyContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionBody + + return p +} + +func (s *FunctionBodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionBodyContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *FunctionBodyContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *FunctionBodyContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FunctionBodyContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionBodyContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionBodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionBodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionBody(s) + } +} + +func (s *FunctionBodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionBody(s) + } +} + +func (p *KotlinParser) FunctionBody() (localctx IFunctionBodyContext) { + this := p + _ = this + + localctx = NewFunctionBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, KotlinParserRULE_functionBody) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(1116) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLCURL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1107) + p.Block() + } + + case KotlinParserASSIGNMENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1108) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(1112) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1109) + p.Match(KotlinParserNL) + } + + p.SetState(1114) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1115) + p.Expression() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IVariableDeclarationContext is an interface to support dynamic dispatch. +type IVariableDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsVariableDeclarationContext differentiates from other interfaces. + IsVariableDeclarationContext() +} + +type VariableDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariableDeclarationContext() *VariableDeclarationContext { + var p = new(VariableDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_variableDeclaration + return p +} + +func (*VariableDeclarationContext) IsVariableDeclarationContext() {} + +func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext { + var p = new(VariableDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_variableDeclaration + + return p +} + +func (s *VariableDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariableDeclarationContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *VariableDeclarationContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *VariableDeclarationContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *VariableDeclarationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *VariableDeclarationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *VariableDeclarationContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *VariableDeclarationContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *VariableDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariableDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterVariableDeclaration(s) + } +} + +func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitVariableDeclaration(s) + } +} + +func (p *KotlinParser) VariableDeclaration() (localctx IVariableDeclarationContext) { + this := p + _ = this + + localctx = NewVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, KotlinParserRULE_variableDeclaration) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1121) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS { + { + p.SetState(1118) + p.Annotation() + } + + p.SetState(1123) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(1127) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1124) + p.Match(KotlinParserNL) + } + + p.SetState(1129) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1130) + p.SimpleIdentifier() + } + p.SetState(1145) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, p.GetParserRuleContext()) == 1 { + p.SetState(1134) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1131) + p.Match(KotlinParserNL) + } + + p.SetState(1136) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1137) + p.Match(KotlinParserCOLON) + } + p.SetState(1141) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1138) + p.Match(KotlinParserNL) + } + + p.SetState(1143) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1144) + p.Type_() + } + + } + + return localctx +} + +// IMultiVariableDeclarationContext is an interface to support dynamic dispatch. +type IMultiVariableDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiVariableDeclarationContext differentiates from other interfaces. + IsMultiVariableDeclarationContext() +} + +type MultiVariableDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiVariableDeclarationContext() *MultiVariableDeclarationContext { + var p = new(MultiVariableDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiVariableDeclaration + return p +} + +func (*MultiVariableDeclarationContext) IsMultiVariableDeclarationContext() {} + +func NewMultiVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiVariableDeclarationContext { + var p = new(MultiVariableDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiVariableDeclaration + + return p +} + +func (s *MultiVariableDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiVariableDeclarationContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *MultiVariableDeclarationContext) AllVariableDeclaration() []IVariableDeclarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariableDeclarationContext); ok { + len++ + } + } + + tst := make([]IVariableDeclarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariableDeclarationContext); ok { + tst[i] = t.(IVariableDeclarationContext) + i++ + } + } + + return tst +} + +func (s *MultiVariableDeclarationContext) VariableDeclaration(i int) IVariableDeclarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableDeclarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariableDeclarationContext) +} + +func (s *MultiVariableDeclarationContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *MultiVariableDeclarationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *MultiVariableDeclarationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *MultiVariableDeclarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *MultiVariableDeclarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *MultiVariableDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiVariableDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiVariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiVariableDeclaration(s) + } +} + +func (s *MultiVariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiVariableDeclaration(s) + } +} + +func (p *KotlinParser) MultiVariableDeclaration() (localctx IMultiVariableDeclarationContext) { + this := p + _ = this + + localctx = NewMultiVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, KotlinParserRULE_multiVariableDeclaration) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1147) + p.Match(KotlinParserLPAREN) + } + p.SetState(1151) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1148) + p.Match(KotlinParserNL) + } + + } + p.SetState(1153) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) + } + { + p.SetState(1154) + p.VariableDeclaration() + } + p.SetState(1171) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 143, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1158) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1155) + p.Match(KotlinParserNL) + } + + p.SetState(1160) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1161) + p.Match(KotlinParserCOMMA) + } + p.SetState(1165) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 142, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1162) + p.Match(KotlinParserNL) + } + + } + p.SetState(1167) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 142, p.GetParserRuleContext()) + } + { + p.SetState(1168) + p.VariableDeclaration() + } + + } + p.SetState(1173) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 143, p.GetParserRuleContext()) + } + p.SetState(1181) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 145, p.GetParserRuleContext()) == 1 { + p.SetState(1177) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1174) + p.Match(KotlinParserNL) + } + + p.SetState(1179) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1180) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(1186) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1183) + p.Match(KotlinParserNL) + } + + p.SetState(1188) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1189) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IPropertyDeclarationContext is an interface to support dynamic dispatch. +type IPropertyDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPropertyDeclarationContext differentiates from other interfaces. + IsPropertyDeclarationContext() +} + +type PropertyDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPropertyDeclarationContext() *PropertyDeclarationContext { + var p = new(PropertyDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_propertyDeclaration + return p +} + +func (*PropertyDeclarationContext) IsPropertyDeclarationContext() {} + +func NewPropertyDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyDeclarationContext { + var p = new(PropertyDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_propertyDeclaration + + return p +} + +func (s *PropertyDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyDeclarationContext) VAL() antlr.TerminalNode { + return s.GetToken(KotlinParserVAL, 0) +} + +func (s *PropertyDeclarationContext) VAR() antlr.TerminalNode { + return s.GetToken(KotlinParserVAR, 0) +} + +func (s *PropertyDeclarationContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *PropertyDeclarationContext) TypeParameters() ITypeParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeParametersContext) +} + +func (s *PropertyDeclarationContext) ReceiverType() IReceiverTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReceiverTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReceiverTypeContext) +} + +func (s *PropertyDeclarationContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *PropertyDeclarationContext) TypeConstraints() ITypeConstraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeConstraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeConstraintsContext) +} + +func (s *PropertyDeclarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(KotlinParserSEMICOLON, 0) +} + +func (s *PropertyDeclarationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *PropertyDeclarationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *PropertyDeclarationContext) MultiVariableDeclaration() IMultiVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiVariableDeclarationContext) +} + +func (s *PropertyDeclarationContext) VariableDeclaration() IVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableDeclarationContext) +} + +func (s *PropertyDeclarationContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *PropertyDeclarationContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PropertyDeclarationContext) PropertyDelegate() IPropertyDelegateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyDelegateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyDelegateContext) +} + +func (s *PropertyDeclarationContext) Getter() IGetterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGetterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGetterContext) +} + +func (s *PropertyDeclarationContext) Setter() ISetterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetterContext) +} + +func (s *PropertyDeclarationContext) Semi() ISemiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISemiContext) +} + +func (s *PropertyDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPropertyDeclaration(s) + } +} + +func (s *PropertyDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPropertyDeclaration(s) + } +} + +func (p *KotlinParser) PropertyDeclaration() (localctx IPropertyDeclarationContext) { + this := p + _ = this + + localctx = NewPropertyDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, KotlinParserRULE_propertyDeclaration) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1192) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(1191) + p.Modifiers() + } + + } + { + p.SetState(1194) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserVAL || _la == KotlinParserVAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1202) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 149, p.GetParserRuleContext()) == 1 { + p.SetState(1198) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1195) + p.Match(KotlinParserNL) + } + + p.SetState(1200) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1201) + p.TypeParameters() + } + + } + p.SetState(1219) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext()) == 1 { + p.SetState(1207) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1204) + p.Match(KotlinParserNL) + } + + p.SetState(1209) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1210) + p.ReceiverType() + } + p.SetState(1214) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1211) + p.Match(KotlinParserNL) + } + + p.SetState(1216) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1217) + p.Match(KotlinParserDOT) + } + + } + + p.SetState(1224) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 153, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1221) + p.Match(KotlinParserNL) + } + + } + p.SetState(1226) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 153, p.GetParserRuleContext()) + } + p.SetState(1229) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLPAREN: + { + p.SetState(1227) + p.MultiVariableDeclaration() + } + + case KotlinParserNL, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1228) + p.VariableDeclaration() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(1238) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext()) == 1 { + p.SetState(1234) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1231) + p.Match(KotlinParserNL) + } + + p.SetState(1236) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1237) + p.TypeConstraints() + } + + } + p.SetState(1257) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 { + p.SetState(1243) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1240) + p.Match(KotlinParserNL) + } + + p.SetState(1245) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(1255) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserASSIGNMENT: + { + p.SetState(1246) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(1250) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1247) + p.Match(KotlinParserNL) + } + + p.SetState(1252) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1253) + p.Expression() + } + + case KotlinParserBY: + { + p.SetState(1254) + p.PropertyDelegate() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + } + p.SetState(1265) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 162, p.GetParserRuleContext()) == 1 { + p.SetState(1260) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == KotlinParserNL { + { + p.SetState(1259) + p.Match(KotlinParserNL) + } + + p.SetState(1262) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1264) + p.Match(KotlinParserSEMICOLON) + } + + } + p.SetState(1270) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1267) + p.Match(KotlinParserNL) + } + + } + p.SetState(1272) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext()) + } + p.SetState(1303) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext()) { + case 1: + p.SetState(1274) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) == 1 { + { + p.SetState(1273) + p.Getter() + } + + } + p.SetState(1286) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 167, p.GetParserRuleContext()) == 1 { + p.SetState(1279) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1276) + p.Match(KotlinParserNL) + } + + } + p.SetState(1281) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) + } + p.SetState(1283) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserNL || _la == KotlinParserSEMICOLON { + { + p.SetState(1282) + p.Semi() + } + + } + { + p.SetState(1285) + p.Setter() + } + + } + + case 2: + p.SetState(1289) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 168, p.GetParserRuleContext()) == 1 { + { + p.SetState(1288) + p.Setter() + } + + } + p.SetState(1301) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 171, p.GetParserRuleContext()) == 1 { + p.SetState(1294) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 169, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1291) + p.Match(KotlinParserNL) + } + + } + p.SetState(1296) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 169, p.GetParserRuleContext()) + } + p.SetState(1298) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserNL || _la == KotlinParserSEMICOLON { + { + p.SetState(1297) + p.Semi() + } + + } + { + p.SetState(1300) + p.Getter() + } + + } + + } + + return localctx +} + +// IPropertyDelegateContext is an interface to support dynamic dispatch. +type IPropertyDelegateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPropertyDelegateContext differentiates from other interfaces. + IsPropertyDelegateContext() +} + +type PropertyDelegateContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPropertyDelegateContext() *PropertyDelegateContext { + var p = new(PropertyDelegateContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_propertyDelegate + return p +} + +func (*PropertyDelegateContext) IsPropertyDelegateContext() {} + +func NewPropertyDelegateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyDelegateContext { + var p = new(PropertyDelegateContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_propertyDelegate + + return p +} + +func (s *PropertyDelegateContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyDelegateContext) BY() antlr.TerminalNode { + return s.GetToken(KotlinParserBY, 0) +} + +func (s *PropertyDelegateContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PropertyDelegateContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *PropertyDelegateContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *PropertyDelegateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyDelegateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyDelegateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPropertyDelegate(s) + } +} + +func (s *PropertyDelegateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPropertyDelegate(s) + } +} + +func (p *KotlinParser) PropertyDelegate() (localctx IPropertyDelegateContext) { + this := p + _ = this + + localctx = NewPropertyDelegateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, KotlinParserRULE_propertyDelegate) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1305) + p.Match(KotlinParserBY) + } + p.SetState(1309) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1306) + p.Match(KotlinParserNL) + } + + p.SetState(1311) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1312) + p.Expression() + } + + return localctx +} + +// IGetterContext is an interface to support dynamic dispatch. +type IGetterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsGetterContext differentiates from other interfaces. + IsGetterContext() +} + +type GetterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGetterContext() *GetterContext { + var p = new(GetterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_getter + return p +} + +func (*GetterContext) IsGetterContext() {} + +func NewGetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetterContext { + var p = new(GetterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_getter + + return p +} + +func (s *GetterContext) GetParser() antlr.Parser { return s.parser } + +func (s *GetterContext) GET() antlr.TerminalNode { + return s.GetToken(KotlinParserGET, 0) +} + +func (s *GetterContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *GetterContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *GetterContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *GetterContext) FunctionBody() IFunctionBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionBodyContext) +} + +func (s *GetterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *GetterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *GetterContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *GetterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *GetterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GetterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GetterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterGetter(s) + } +} + +func (s *GetterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitGetter(s) + } +} + +func (p *KotlinParser) Getter() (localctx IGetterContext) { + this := p + _ = this + + localctx = NewGetterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, KotlinParserRULE_getter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1315) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(1314) + p.Modifiers() + } + + } + { + p.SetState(1317) + p.Match(KotlinParserGET) + } + p.SetState(1355) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 181, p.GetParserRuleContext()) == 1 { + p.SetState(1321) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1318) + p.Match(KotlinParserNL) + } + + p.SetState(1323) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1324) + p.Match(KotlinParserLPAREN) + } + p.SetState(1328) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1325) + p.Match(KotlinParserNL) + } + + p.SetState(1330) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1331) + p.Match(KotlinParserRPAREN) + } + p.SetState(1346) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 179, p.GetParserRuleContext()) == 1 { + p.SetState(1335) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1332) + p.Match(KotlinParserNL) + } + + p.SetState(1337) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1338) + p.Match(KotlinParserCOLON) + } + p.SetState(1342) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1339) + p.Match(KotlinParserNL) + } + + p.SetState(1344) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1345) + p.Type_() + } + + } + p.SetState(1351) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1348) + p.Match(KotlinParserNL) + } + + p.SetState(1353) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1354) + p.FunctionBody() + } + + } + + return localctx +} + +// ISetterContext is an interface to support dynamic dispatch. +type ISetterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSetterContext differentiates from other interfaces. + IsSetterContext() +} + +type SetterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetterContext() *SetterContext { + var p = new(SetterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_setter + return p +} + +func (*SetterContext) IsSetterContext() {} + +func NewSetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetterContext { + var p = new(SetterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_setter + + return p +} + +func (s *SetterContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetterContext) SET() antlr.TerminalNode { + return s.GetToken(KotlinParserSET, 0) +} + +func (s *SetterContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *SetterContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *SetterContext) FunctionValueParameterWithOptionalType() IFunctionValueParameterWithOptionalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionValueParameterWithOptionalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionValueParameterWithOptionalTypeContext) +} + +func (s *SetterContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *SetterContext) FunctionBody() IFunctionBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionBodyContext) +} + +func (s *SetterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SetterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SetterContext) COMMA() antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, 0) +} + +func (s *SetterContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *SetterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *SetterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSetter(s) + } +} + +func (s *SetterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSetter(s) + } +} + +func (p *KotlinParser) Setter() (localctx ISetterContext) { + this := p + _ = this + + localctx = NewSetterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, KotlinParserRULE_setter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1358) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(1357) + p.Modifiers() + } + + } + { + p.SetState(1360) + p.Match(KotlinParserSET) + } + p.SetState(1415) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext()) == 1 { + p.SetState(1364) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1361) + p.Match(KotlinParserNL) + } + + p.SetState(1366) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1367) + p.Match(KotlinParserLPAREN) + } + p.SetState(1371) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1368) + p.Match(KotlinParserNL) + } + + p.SetState(1373) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1374) + p.FunctionValueParameterWithOptionalType() + } + p.SetState(1382) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 186, p.GetParserRuleContext()) == 1 { + p.SetState(1378) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1375) + p.Match(KotlinParserNL) + } + + p.SetState(1380) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1381) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(1387) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1384) + p.Match(KotlinParserNL) + } + + p.SetState(1389) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1390) + p.Match(KotlinParserRPAREN) + } + p.SetState(1405) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext()) == 1 { + p.SetState(1394) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1391) + p.Match(KotlinParserNL) + } + + p.SetState(1396) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1397) + p.Match(KotlinParserCOLON) + } + p.SetState(1401) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1398) + p.Match(KotlinParserNL) + } + + p.SetState(1403) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1404) + p.Type_() + } + + } + p.SetState(1410) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1407) + p.Match(KotlinParserNL) + } + + p.SetState(1412) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1413) + p.FunctionBody() + } + + } + + return localctx +} + +// IParametersWithOptionalTypeContext is an interface to support dynamic dispatch. +type IParametersWithOptionalTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParametersWithOptionalTypeContext differentiates from other interfaces. + IsParametersWithOptionalTypeContext() +} + +type ParametersWithOptionalTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParametersWithOptionalTypeContext() *ParametersWithOptionalTypeContext { + var p = new(ParametersWithOptionalTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parametersWithOptionalType + return p +} + +func (*ParametersWithOptionalTypeContext) IsParametersWithOptionalTypeContext() {} + +func NewParametersWithOptionalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParametersWithOptionalTypeContext { + var p = new(ParametersWithOptionalTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parametersWithOptionalType + + return p +} + +func (s *ParametersWithOptionalTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParametersWithOptionalTypeContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ParametersWithOptionalTypeContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ParametersWithOptionalTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParametersWithOptionalTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParametersWithOptionalTypeContext) AllFunctionValueParameterWithOptionalType() []IFunctionValueParameterWithOptionalTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionValueParameterWithOptionalTypeContext); ok { + len++ + } + } + + tst := make([]IFunctionValueParameterWithOptionalTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionValueParameterWithOptionalTypeContext); ok { + tst[i] = t.(IFunctionValueParameterWithOptionalTypeContext) + i++ + } + } + + return tst +} + +func (s *ParametersWithOptionalTypeContext) FunctionValueParameterWithOptionalType(i int) IFunctionValueParameterWithOptionalTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionValueParameterWithOptionalTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionValueParameterWithOptionalTypeContext) +} + +func (s *ParametersWithOptionalTypeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *ParametersWithOptionalTypeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *ParametersWithOptionalTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParametersWithOptionalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParametersWithOptionalTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParametersWithOptionalType(s) + } +} + +func (s *ParametersWithOptionalTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParametersWithOptionalType(s) + } +} + +func (p *KotlinParser) ParametersWithOptionalType() (localctx IParametersWithOptionalTypeContext) { + this := p + _ = this + + localctx = NewParametersWithOptionalTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, KotlinParserRULE_parametersWithOptionalType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1417) + p.Match(KotlinParserLPAREN) + } + p.SetState(1421) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 193, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1418) + p.Match(KotlinParserNL) + } + + } + p.SetState(1423) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 193, p.GetParserRuleContext()) + } + p.SetState(1453) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64((_la-40)) & ^0x3f) == 0 && ((int64(1)<<(_la-40))&13668035483140101) != 0 || (int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&2200096997375) != 0 { + { + p.SetState(1424) + p.FunctionValueParameterWithOptionalType() + } + p.SetState(1441) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 196, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1428) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1425) + p.Match(KotlinParserNL) + } + + p.SetState(1430) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1431) + p.Match(KotlinParserCOMMA) + } + p.SetState(1435) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1432) + p.Match(KotlinParserNL) + } + + p.SetState(1437) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1438) + p.FunctionValueParameterWithOptionalType() + } + + } + p.SetState(1443) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 196, p.GetParserRuleContext()) + } + p.SetState(1451) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 { + p.SetState(1447) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1444) + p.Match(KotlinParserNL) + } + + p.SetState(1449) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1450) + p.Match(KotlinParserCOMMA) + } + + } + + } + p.SetState(1458) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1455) + p.Match(KotlinParserNL) + } + + p.SetState(1460) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1461) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IFunctionValueParameterWithOptionalTypeContext is an interface to support dynamic dispatch. +type IFunctionValueParameterWithOptionalTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionValueParameterWithOptionalTypeContext differentiates from other interfaces. + IsFunctionValueParameterWithOptionalTypeContext() +} + +type FunctionValueParameterWithOptionalTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionValueParameterWithOptionalTypeContext() *FunctionValueParameterWithOptionalTypeContext { + var p = new(FunctionValueParameterWithOptionalTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionValueParameterWithOptionalType + return p +} + +func (*FunctionValueParameterWithOptionalTypeContext) IsFunctionValueParameterWithOptionalTypeContext() { +} + +func NewFunctionValueParameterWithOptionalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionValueParameterWithOptionalTypeContext { + var p = new(FunctionValueParameterWithOptionalTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionValueParameterWithOptionalType + + return p +} + +func (s *FunctionValueParameterWithOptionalTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionValueParameterWithOptionalTypeContext) ParameterWithOptionalType() IParameterWithOptionalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterWithOptionalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterWithOptionalTypeContext) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) ParameterModifiers() IParameterModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterModifiersContext) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionValueParameterWithOptionalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionValueParameterWithOptionalTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionValueParameterWithOptionalType(s) + } +} + +func (s *FunctionValueParameterWithOptionalTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionValueParameterWithOptionalType(s) + } +} + +func (p *KotlinParser) FunctionValueParameterWithOptionalType() (localctx IFunctionValueParameterWithOptionalTypeContext) { + this := p + _ = this + + localctx = NewFunctionValueParameterWithOptionalTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, KotlinParserRULE_functionValueParameterWithOptionalType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1464) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 201, p.GetParserRuleContext()) == 1 { + { + p.SetState(1463) + p.ParameterModifiers() + } + + } + { + p.SetState(1466) + p.ParameterWithOptionalType() + } + p.SetState(1481) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 204, p.GetParserRuleContext()) == 1 { + p.SetState(1470) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1467) + p.Match(KotlinParserNL) + } + + p.SetState(1472) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1473) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(1477) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1474) + p.Match(KotlinParserNL) + } + + p.SetState(1479) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1480) + p.Expression() + } + + } + + return localctx +} + +// IParameterWithOptionalTypeContext is an interface to support dynamic dispatch. +type IParameterWithOptionalTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParameterWithOptionalTypeContext differentiates from other interfaces. + IsParameterWithOptionalTypeContext() +} + +type ParameterWithOptionalTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterWithOptionalTypeContext() *ParameterWithOptionalTypeContext { + var p = new(ParameterWithOptionalTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parameterWithOptionalType + return p +} + +func (*ParameterWithOptionalTypeContext) IsParameterWithOptionalTypeContext() {} + +func NewParameterWithOptionalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterWithOptionalTypeContext { + var p = new(ParameterWithOptionalTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parameterWithOptionalType + + return p +} + +func (s *ParameterWithOptionalTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterWithOptionalTypeContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ParameterWithOptionalTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParameterWithOptionalTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParameterWithOptionalTypeContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ParameterWithOptionalTypeContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *ParameterWithOptionalTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterWithOptionalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterWithOptionalTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParameterWithOptionalType(s) + } +} + +func (s *ParameterWithOptionalTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParameterWithOptionalType(s) + } +} + +func (p *KotlinParser) ParameterWithOptionalType() (localctx IParameterWithOptionalTypeContext) { + this := p + _ = this + + localctx = NewParameterWithOptionalTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, KotlinParserRULE_parameterWithOptionalType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1483) + p.SimpleIdentifier() + } + p.SetState(1487) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 205, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1484) + p.Match(KotlinParserNL) + } + + } + p.SetState(1489) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 205, p.GetParserRuleContext()) + } + p.SetState(1498) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserCOLON { + { + p.SetState(1490) + p.Match(KotlinParserCOLON) + } + p.SetState(1494) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1491) + p.Match(KotlinParserNL) + } + + p.SetState(1496) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1497) + p.Type_() + } + + } + + return localctx +} + +// IParameterContext is an interface to support dynamic dispatch. +type IParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParameterContext differentiates from other interfaces. + IsParameterContext() +} + +type ParameterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterContext() *ParameterContext { + var p = new(ParameterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parameter + return p +} + +func (*ParameterContext) IsParameterContext() {} + +func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext { + var p = new(ParameterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parameter + + return p +} + +func (s *ParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ParameterContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ParameterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *ParameterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParameterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParameter(s) + } +} + +func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParameter(s) + } +} + +func (p *KotlinParser) Parameter() (localctx IParameterContext) { + this := p + _ = this + + localctx = NewParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, KotlinParserRULE_parameter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1500) + p.SimpleIdentifier() + } + p.SetState(1504) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1501) + p.Match(KotlinParserNL) + } + + p.SetState(1506) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1507) + p.Match(KotlinParserCOLON) + } + p.SetState(1511) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1508) + p.Match(KotlinParserNL) + } + + p.SetState(1513) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1514) + p.Type_() + } + + return localctx +} + +// IObjectDeclarationContext is an interface to support dynamic dispatch. +type IObjectDeclarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsObjectDeclarationContext differentiates from other interfaces. + IsObjectDeclarationContext() +} + +type ObjectDeclarationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObjectDeclarationContext() *ObjectDeclarationContext { + var p = new(ObjectDeclarationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_objectDeclaration + return p +} + +func (*ObjectDeclarationContext) IsObjectDeclarationContext() {} + +func NewObjectDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectDeclarationContext { + var p = new(ObjectDeclarationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_objectDeclaration + + return p +} + +func (s *ObjectDeclarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ObjectDeclarationContext) OBJECT() antlr.TerminalNode { + return s.GetToken(KotlinParserOBJECT, 0) +} + +func (s *ObjectDeclarationContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ObjectDeclarationContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *ObjectDeclarationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ObjectDeclarationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ObjectDeclarationContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ObjectDeclarationContext) DelegationSpecifiers() IDelegationSpecifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelegationSpecifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelegationSpecifiersContext) +} + +func (s *ObjectDeclarationContext) ClassBody() IClassBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassBodyContext) +} + +func (s *ObjectDeclarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ObjectDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ObjectDeclarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterObjectDeclaration(s) + } +} + +func (s *ObjectDeclarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitObjectDeclaration(s) + } +} + +func (p *KotlinParser) ObjectDeclaration() (localctx IObjectDeclarationContext) { + this := p + _ = this + + localctx = NewObjectDeclarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, KotlinParserRULE_objectDeclaration) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1517) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(1516) + p.Modifiers() + } + + } + { + p.SetState(1519) + p.Match(KotlinParserOBJECT) + } + p.SetState(1523) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1520) + p.Match(KotlinParserNL) + } + + p.SetState(1525) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1526) + p.SimpleIdentifier() + } + p.SetState(1541) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 214, p.GetParserRuleContext()) == 1 { + p.SetState(1530) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1527) + p.Match(KotlinParserNL) + } + + p.SetState(1532) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1533) + p.Match(KotlinParserCOLON) + } + p.SetState(1537) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 213, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1534) + p.Match(KotlinParserNL) + } + + } + p.SetState(1539) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 213, p.GetParserRuleContext()) + } + { + p.SetState(1540) + p.DelegationSpecifiers() + } + + } + p.SetState(1550) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 216, p.GetParserRuleContext()) == 1 { + p.SetState(1546) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1543) + p.Match(KotlinParserNL) + } + + p.SetState(1548) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1549) + p.ClassBody() + } + + } + + return localctx +} + +// ISecondaryConstructorContext is an interface to support dynamic dispatch. +type ISecondaryConstructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSecondaryConstructorContext differentiates from other interfaces. + IsSecondaryConstructorContext() +} + +type SecondaryConstructorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecondaryConstructorContext() *SecondaryConstructorContext { + var p = new(SecondaryConstructorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_secondaryConstructor + return p +} + +func (*SecondaryConstructorContext) IsSecondaryConstructorContext() {} + +func NewSecondaryConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SecondaryConstructorContext { + var p = new(SecondaryConstructorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_secondaryConstructor + + return p +} + +func (s *SecondaryConstructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *SecondaryConstructorContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(KotlinParserCONSTRUCTOR, 0) +} + +func (s *SecondaryConstructorContext) FunctionValueParameters() IFunctionValueParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionValueParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionValueParametersContext) +} + +func (s *SecondaryConstructorContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *SecondaryConstructorContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SecondaryConstructorContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SecondaryConstructorContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *SecondaryConstructorContext) ConstructorDelegationCall() IConstructorDelegationCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructorDelegationCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructorDelegationCallContext) +} + +func (s *SecondaryConstructorContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *SecondaryConstructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SecondaryConstructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SecondaryConstructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSecondaryConstructor(s) + } +} + +func (s *SecondaryConstructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSecondaryConstructor(s) + } +} + +func (p *KotlinParser) SecondaryConstructor() (localctx ISecondaryConstructorContext) { + this := p + _ = this + + localctx = NewSecondaryConstructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, KotlinParserRULE_secondaryConstructor) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1553) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS || (int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&234881023) != 0 { + { + p.SetState(1552) + p.Modifiers() + } + + } + { + p.SetState(1555) + p.Match(KotlinParserCONSTRUCTOR) + } + p.SetState(1559) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1556) + p.Match(KotlinParserNL) + } + + p.SetState(1561) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1562) + p.FunctionValueParameters() + } + p.SetState(1577) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 221, p.GetParserRuleContext()) == 1 { + p.SetState(1566) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1563) + p.Match(KotlinParserNL) + } + + p.SetState(1568) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1569) + p.Match(KotlinParserCOLON) + } + p.SetState(1573) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1570) + p.Match(KotlinParserNL) + } + + p.SetState(1575) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1576) + p.ConstructorDelegationCall() + } + + } + p.SetState(1582) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 222, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1579) + p.Match(KotlinParserNL) + } + + } + p.SetState(1584) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 222, p.GetParserRuleContext()) + } + p.SetState(1586) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserLCURL { + { + p.SetState(1585) + p.Block() + } + + } + + return localctx +} + +// IConstructorDelegationCallContext is an interface to support dynamic dispatch. +type IConstructorDelegationCallContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsConstructorDelegationCallContext differentiates from other interfaces. + IsConstructorDelegationCallContext() +} + +type ConstructorDelegationCallContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstructorDelegationCallContext() *ConstructorDelegationCallContext { + var p = new(ConstructorDelegationCallContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_constructorDelegationCall + return p +} + +func (*ConstructorDelegationCallContext) IsConstructorDelegationCallContext() {} + +func NewConstructorDelegationCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstructorDelegationCallContext { + var p = new(ConstructorDelegationCallContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_constructorDelegationCall + + return p +} + +func (s *ConstructorDelegationCallContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstructorDelegationCallContext) ValueArguments() IValueArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueArgumentsContext) +} + +func (s *ConstructorDelegationCallContext) THIS() antlr.TerminalNode { + return s.GetToken(KotlinParserTHIS, 0) +} + +func (s *ConstructorDelegationCallContext) SUPER() antlr.TerminalNode { + return s.GetToken(KotlinParserSUPER, 0) +} + +func (s *ConstructorDelegationCallContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ConstructorDelegationCallContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ConstructorDelegationCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstructorDelegationCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstructorDelegationCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterConstructorDelegationCall(s) + } +} + +func (s *ConstructorDelegationCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitConstructorDelegationCall(s) + } +} + +func (p *KotlinParser) ConstructorDelegationCall() (localctx IConstructorDelegationCallContext) { + this := p + _ = this + + localctx = NewConstructorDelegationCallContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, KotlinParserRULE_constructorDelegationCall) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1588) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserTHIS || _la == KotlinParserSUPER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1592) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1589) + p.Match(KotlinParserNL) + } + + p.SetState(1594) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1595) + p.ValueArguments() + } + + return localctx +} + +// IEnumClassBodyContext is an interface to support dynamic dispatch. +type IEnumClassBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsEnumClassBodyContext differentiates from other interfaces. + IsEnumClassBodyContext() +} + +type EnumClassBodyContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnumClassBodyContext() *EnumClassBodyContext { + var p = new(EnumClassBodyContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_enumClassBody + return p +} + +func (*EnumClassBodyContext) IsEnumClassBodyContext() {} + +func NewEnumClassBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumClassBodyContext { + var p = new(EnumClassBodyContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_enumClassBody + + return p +} + +func (s *EnumClassBodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *EnumClassBodyContext) LCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserLCURL, 0) +} + +func (s *EnumClassBodyContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *EnumClassBodyContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *EnumClassBodyContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *EnumClassBodyContext) EnumEntries() IEnumEntriesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnumEntriesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnumEntriesContext) +} + +func (s *EnumClassBodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(KotlinParserSEMICOLON, 0) +} + +func (s *EnumClassBodyContext) ClassMemberDeclarations() IClassMemberDeclarationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassMemberDeclarationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassMemberDeclarationsContext) +} + +func (s *EnumClassBodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EnumClassBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EnumClassBodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterEnumClassBody(s) + } +} + +func (s *EnumClassBodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitEnumClassBody(s) + } +} + +func (p *KotlinParser) EnumClassBody() (localctx IEnumClassBodyContext) { + this := p + _ = this + + localctx = NewEnumClassBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, KotlinParserRULE_enumClassBody) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1597) + p.Match(KotlinParserLCURL) + } + p.SetState(1601) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 225, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1598) + p.Match(KotlinParserNL) + } + + } + p.SetState(1603) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 225, p.GetParserRuleContext()) + } + p.SetState(1605) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64((_la-40)) & ^0x3f) == 0 && ((int64(1)<<(_la-40))&13668035483140101) != 0 || (int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&2200096997375) != 0 { + { + p.SetState(1604) + p.EnumEntries() + } + + } + p.SetState(1621) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 229, p.GetParserRuleContext()) == 1 { + p.SetState(1610) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1607) + p.Match(KotlinParserNL) + } + + p.SetState(1612) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1613) + p.Match(KotlinParserSEMICOLON) + } + p.SetState(1617) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 228, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1614) + p.Match(KotlinParserNL) + } + + } + p.SetState(1619) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 228, p.GetParserRuleContext()) + } + { + p.SetState(1620) + p.ClassMemberDeclarations() + } + + } + p.SetState(1626) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1623) + p.Match(KotlinParserNL) + } + + p.SetState(1628) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1629) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// IEnumEntriesContext is an interface to support dynamic dispatch. +type IEnumEntriesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsEnumEntriesContext differentiates from other interfaces. + IsEnumEntriesContext() +} + +type EnumEntriesContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnumEntriesContext() *EnumEntriesContext { + var p = new(EnumEntriesContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_enumEntries + return p +} + +func (*EnumEntriesContext) IsEnumEntriesContext() {} + +func NewEnumEntriesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumEntriesContext { + var p = new(EnumEntriesContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_enumEntries + + return p +} + +func (s *EnumEntriesContext) GetParser() antlr.Parser { return s.parser } + +func (s *EnumEntriesContext) AllEnumEntry() []IEnumEntryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnumEntryContext); ok { + len++ + } + } + + tst := make([]IEnumEntryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnumEntryContext); ok { + tst[i] = t.(IEnumEntryContext) + i++ + } + } + + return tst +} + +func (s *EnumEntriesContext) EnumEntry(i int) IEnumEntryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnumEntryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnumEntryContext) +} + +func (s *EnumEntriesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *EnumEntriesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *EnumEntriesContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *EnumEntriesContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *EnumEntriesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EnumEntriesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EnumEntriesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterEnumEntries(s) + } +} + +func (s *EnumEntriesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitEnumEntries(s) + } +} + +func (p *KotlinParser) EnumEntries() (localctx IEnumEntriesContext) { + this := p + _ = this + + localctx = NewEnumEntriesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, KotlinParserRULE_enumEntries) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1631) + p.EnumEntry() + } + p.SetState(1648) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 233, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1635) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1632) + p.Match(KotlinParserNL) + } + + p.SetState(1637) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1638) + p.Match(KotlinParserCOMMA) + } + p.SetState(1642) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1639) + p.Match(KotlinParserNL) + } + + p.SetState(1644) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1645) + p.EnumEntry() + } + + } + p.SetState(1650) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 233, p.GetParserRuleContext()) + } + p.SetState(1654) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 234, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1651) + p.Match(KotlinParserNL) + } + + } + p.SetState(1656) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 234, p.GetParserRuleContext()) + } + p.SetState(1658) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserCOMMA { + { + p.SetState(1657) + p.Match(KotlinParserCOMMA) + } + + } + + return localctx +} + +// IEnumEntryContext is an interface to support dynamic dispatch. +type IEnumEntryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsEnumEntryContext differentiates from other interfaces. + IsEnumEntryContext() +} + +type EnumEntryContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnumEntryContext() *EnumEntryContext { + var p = new(EnumEntryContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_enumEntry + return p +} + +func (*EnumEntryContext) IsEnumEntryContext() {} + +func NewEnumEntryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumEntryContext { + var p = new(EnumEntryContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_enumEntry + + return p +} + +func (s *EnumEntryContext) GetParser() antlr.Parser { return s.parser } + +func (s *EnumEntryContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *EnumEntryContext) Modifiers() IModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifiersContext) +} + +func (s *EnumEntryContext) ValueArguments() IValueArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueArgumentsContext) +} + +func (s *EnumEntryContext) ClassBody() IClassBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassBodyContext) +} + +func (s *EnumEntryContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *EnumEntryContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *EnumEntryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EnumEntryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EnumEntryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterEnumEntry(s) + } +} + +func (s *EnumEntryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitEnumEntry(s) + } +} + +func (p *KotlinParser) EnumEntry() (localctx IEnumEntryContext) { + this := p + _ = this + + localctx = NewEnumEntryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, KotlinParserRULE_enumEntry) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1667) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 237, p.GetParserRuleContext()) == 1 { + { + p.SetState(1660) + p.Modifiers() + } + p.SetState(1664) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1661) + p.Match(KotlinParserNL) + } + + p.SetState(1666) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(1669) + p.SimpleIdentifier() + } + p.SetState(1677) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 239, p.GetParserRuleContext()) == 1 { + p.SetState(1673) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1670) + p.Match(KotlinParserNL) + } + + p.SetState(1675) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1676) + p.ValueArguments() + } + + } + p.SetState(1686) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 241, p.GetParserRuleContext()) == 1 { + p.SetState(1682) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1679) + p.Match(KotlinParserNL) + } + + p.SetState(1684) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1685) + p.ClassBody() + } + + } + + return localctx +} + +// ITypeContext is an interface to support dynamic dispatch. +type ITypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeContext differentiates from other interfaces. + IsTypeContext() +} + +type TypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeContext() *TypeContext { + var p = new(TypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_type + return p +} + +func (*TypeContext) IsTypeContext() {} + +func NewTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeContext { + var p = new(TypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_type + + return p +} + +func (s *TypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeContext) FunctionType() IFunctionTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionTypeContext) +} + +func (s *TypeContext) ParenthesizedType() IParenthesizedTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedTypeContext) +} + +func (s *TypeContext) NullableType() INullableTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INullableTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INullableTypeContext) +} + +func (s *TypeContext) TypeReference() ITypeReferenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeReferenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeReferenceContext) +} + +func (s *TypeContext) DefinitelyNonNullableType() IDefinitelyNonNullableTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinitelyNonNullableTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinitelyNonNullableTypeContext) +} + +func (s *TypeContext) TypeModifiers() ITypeModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeModifiersContext) +} + +func (s *TypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterType(s) + } +} + +func (s *TypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitType(s) + } +} + +func (p *KotlinParser) Type_() (localctx ITypeContext) { + this := p + _ = this + + localctx = NewTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, KotlinParserRULE_type) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1689) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 242, p.GetParserRuleContext()) == 1 { + { + p.SetState(1688) + p.TypeModifiers() + } + + } + p.SetState(1696) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 243, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1691) + p.FunctionType() + } + + case 2: + { + p.SetState(1692) + p.ParenthesizedType() + } + + case 3: + { + p.SetState(1693) + p.NullableType() + } + + case 4: + { + p.SetState(1694) + p.TypeReference() + } + + case 5: + { + p.SetState(1695) + p.DefinitelyNonNullableType() + } + + } + + return localctx +} + +// ITypeReferenceContext is an interface to support dynamic dispatch. +type ITypeReferenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeReferenceContext differentiates from other interfaces. + IsTypeReferenceContext() +} + +type TypeReferenceContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeReferenceContext() *TypeReferenceContext { + var p = new(TypeReferenceContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeReference + return p +} + +func (*TypeReferenceContext) IsTypeReferenceContext() {} + +func NewTypeReferenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeReferenceContext { + var p = new(TypeReferenceContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeReference + + return p +} + +func (s *TypeReferenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeReferenceContext) UserType() IUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *TypeReferenceContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(KotlinParserDYNAMIC, 0) +} + +func (s *TypeReferenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeReferenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeReferenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeReference(s) + } +} + +func (s *TypeReferenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeReference(s) + } +} + +func (p *KotlinParser) TypeReference() (localctx ITypeReferenceContext) { + this := p + _ = this + + localctx = NewTypeReferenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, KotlinParserRULE_typeReference) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(1700) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 244, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1698) + p.UserType() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1699) + p.Match(KotlinParserDYNAMIC) + } + + } + + return localctx +} + +// INullableTypeContext is an interface to support dynamic dispatch. +type INullableTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsNullableTypeContext differentiates from other interfaces. + IsNullableTypeContext() +} + +type NullableTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNullableTypeContext() *NullableTypeContext { + var p = new(NullableTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_nullableType + return p +} + +func (*NullableTypeContext) IsNullableTypeContext() {} + +func NewNullableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullableTypeContext { + var p = new(NullableTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_nullableType + + return p +} + +func (s *NullableTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *NullableTypeContext) TypeReference() ITypeReferenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeReferenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeReferenceContext) +} + +func (s *NullableTypeContext) ParenthesizedType() IParenthesizedTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedTypeContext) +} + +func (s *NullableTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *NullableTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *NullableTypeContext) AllQuest() []IQuestContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuestContext); ok { + len++ + } + } + + tst := make([]IQuestContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuestContext); ok { + tst[i] = t.(IQuestContext) + i++ + } + } + + return tst +} + +func (s *NullableTypeContext) Quest(i int) IQuestContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuestContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuestContext) +} + +func (s *NullableTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NullableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NullableTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterNullableType(s) + } +} + +func (s *NullableTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitNullableType(s) + } +} + +func (p *KotlinParser) NullableType() (localctx INullableTypeContext) { + this := p + _ = this + + localctx = NewNullableTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, KotlinParserRULE_nullableType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1704) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1702) + p.TypeReference() + } + + case KotlinParserLPAREN: + { + p.SetState(1703) + p.ParenthesizedType() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + p.SetState(1709) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1706) + p.Match(KotlinParserNL) + } + + p.SetState(1711) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(1713) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(1712) + p.Quest() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(1715) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 247, p.GetParserRuleContext()) + } + + return localctx +} + +// IQuestContext is an interface to support dynamic dispatch. +type IQuestContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsQuestContext differentiates from other interfaces. + IsQuestContext() +} + +type QuestContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuestContext() *QuestContext { + var p = new(QuestContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_quest + return p +} + +func (*QuestContext) IsQuestContext() {} + +func NewQuestContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuestContext { + var p = new(QuestContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_quest + + return p +} + +func (s *QuestContext) GetParser() antlr.Parser { return s.parser } + +func (s *QuestContext) QUEST_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserQUEST_NO_WS, 0) +} + +func (s *QuestContext) QUEST_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserQUEST_WS, 0) +} + +func (s *QuestContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QuestContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QuestContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterQuest(s) + } +} + +func (s *QuestContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitQuest(s) + } +} + +func (p *KotlinParser) Quest() (localctx IQuestContext) { + this := p + _ = this + + localctx = NewQuestContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, KotlinParserRULE_quest) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1717) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserQUEST_WS || _la == KotlinParserQUEST_NO_WS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IUserTypeContext is an interface to support dynamic dispatch. +type IUserTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsUserTypeContext differentiates from other interfaces. + IsUserTypeContext() +} + +type UserTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserTypeContext() *UserTypeContext { + var p = new(UserTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_userType + return p +} + +func (*UserTypeContext) IsUserTypeContext() {} + +func NewUserTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserTypeContext { + var p = new(UserTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_userType + + return p +} + +func (s *UserTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserTypeContext) AllSimpleUserType() []ISimpleUserTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimpleUserTypeContext); ok { + len++ + } + } + + tst := make([]ISimpleUserTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimpleUserTypeContext); ok { + tst[i] = t.(ISimpleUserTypeContext) + i++ + } + } + + return tst +} + +func (s *UserTypeContext) SimpleUserType(i int) ISimpleUserTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleUserTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimpleUserTypeContext) +} + +func (s *UserTypeContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(KotlinParserDOT) +} + +func (s *UserTypeContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, i) +} + +func (s *UserTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *UserTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *UserTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterUserType(s) + } +} + +func (s *UserTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitUserType(s) + } +} + +func (p *KotlinParser) UserType() (localctx IUserTypeContext) { + this := p + _ = this + + localctx = NewUserTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, KotlinParserRULE_userType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1719) + p.SimpleUserType() + } + p.SetState(1736) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 250, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1723) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1720) + p.Match(KotlinParserNL) + } + + p.SetState(1725) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1726) + p.Match(KotlinParserDOT) + } + p.SetState(1730) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1727) + p.Match(KotlinParserNL) + } + + p.SetState(1732) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1733) + p.SimpleUserType() + } + + } + p.SetState(1738) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 250, p.GetParserRuleContext()) + } + + return localctx +} + +// ISimpleUserTypeContext is an interface to support dynamic dispatch. +type ISimpleUserTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSimpleUserTypeContext differentiates from other interfaces. + IsSimpleUserTypeContext() +} + +type SimpleUserTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimpleUserTypeContext() *SimpleUserTypeContext { + var p = new(SimpleUserTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_simpleUserType + return p +} + +func (*SimpleUserTypeContext) IsSimpleUserTypeContext() {} + +func NewSimpleUserTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleUserTypeContext { + var p = new(SimpleUserTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_simpleUserType + + return p +} + +func (s *SimpleUserTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleUserTypeContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *SimpleUserTypeContext) TypeArguments() ITypeArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeArgumentsContext) +} + +func (s *SimpleUserTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SimpleUserTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SimpleUserTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleUserTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleUserTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSimpleUserType(s) + } +} + +func (s *SimpleUserTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSimpleUserType(s) + } +} + +func (p *KotlinParser) SimpleUserType() (localctx ISimpleUserTypeContext) { + this := p + _ = this + + localctx = NewSimpleUserTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, KotlinParserRULE_simpleUserType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1739) + p.SimpleIdentifier() + } + p.SetState(1747) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 252, p.GetParserRuleContext()) == 1 { + p.SetState(1743) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1740) + p.Match(KotlinParserNL) + } + + p.SetState(1745) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1746) + p.TypeArguments() + } + + } + + return localctx +} + +// ITypeProjectionContext is an interface to support dynamic dispatch. +type ITypeProjectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeProjectionContext differentiates from other interfaces. + IsTypeProjectionContext() +} + +type TypeProjectionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeProjectionContext() *TypeProjectionContext { + var p = new(TypeProjectionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeProjection + return p +} + +func (*TypeProjectionContext) IsTypeProjectionContext() {} + +func NewTypeProjectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeProjectionContext { + var p = new(TypeProjectionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeProjection + + return p +} + +func (s *TypeProjectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeProjectionContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *TypeProjectionContext) TypeProjectionModifiers() ITypeProjectionModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeProjectionModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeProjectionModifiersContext) +} + +func (s *TypeProjectionContext) MULT() antlr.TerminalNode { + return s.GetToken(KotlinParserMULT, 0) +} + +func (s *TypeProjectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeProjectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeProjectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeProjection(s) + } +} + +func (s *TypeProjectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeProjection(s) + } +} + +func (p *KotlinParser) TypeProjection() (localctx ITypeProjectionContext) { + this := p + _ = this + + localctx = NewTypeProjectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, KotlinParserRULE_typeProjection) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(1754) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLPAREN, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserIN, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + p.EnterOuterAlt(localctx, 1) + p.SetState(1750) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 253, p.GetParserRuleContext()) == 1 { + { + p.SetState(1749) + p.TypeProjectionModifiers() + } + + } + { + p.SetState(1752) + p.Type_() + } + + case KotlinParserMULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1753) + p.Match(KotlinParserMULT) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// ITypeProjectionModifiersContext is an interface to support dynamic dispatch. +type ITypeProjectionModifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeProjectionModifiersContext differentiates from other interfaces. + IsTypeProjectionModifiersContext() +} + +type TypeProjectionModifiersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeProjectionModifiersContext() *TypeProjectionModifiersContext { + var p = new(TypeProjectionModifiersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeProjectionModifiers + return p +} + +func (*TypeProjectionModifiersContext) IsTypeProjectionModifiersContext() {} + +func NewTypeProjectionModifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeProjectionModifiersContext { + var p = new(TypeProjectionModifiersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeProjectionModifiers + + return p +} + +func (s *TypeProjectionModifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeProjectionModifiersContext) AllTypeProjectionModifier() []ITypeProjectionModifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeProjectionModifierContext); ok { + len++ + } + } + + tst := make([]ITypeProjectionModifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeProjectionModifierContext); ok { + tst[i] = t.(ITypeProjectionModifierContext) + i++ + } + } + + return tst +} + +func (s *TypeProjectionModifiersContext) TypeProjectionModifier(i int) ITypeProjectionModifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeProjectionModifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeProjectionModifierContext) +} + +func (s *TypeProjectionModifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeProjectionModifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeProjectionModifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeProjectionModifiers(s) + } +} + +func (s *TypeProjectionModifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeProjectionModifiers(s) + } +} + +func (p *KotlinParser) TypeProjectionModifiers() (localctx ITypeProjectionModifiersContext) { + this := p + _ = this + + localctx = NewTypeProjectionModifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, KotlinParserRULE_typeProjectionModifiers) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1757) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(1756) + p.TypeProjectionModifier() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(1759) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 255, p.GetParserRuleContext()) + } + + return localctx +} + +// ITypeProjectionModifierContext is an interface to support dynamic dispatch. +type ITypeProjectionModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeProjectionModifierContext differentiates from other interfaces. + IsTypeProjectionModifierContext() +} + +type TypeProjectionModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeProjectionModifierContext() *TypeProjectionModifierContext { + var p = new(TypeProjectionModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeProjectionModifier + return p +} + +func (*TypeProjectionModifierContext) IsTypeProjectionModifierContext() {} + +func NewTypeProjectionModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeProjectionModifierContext { + var p = new(TypeProjectionModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeProjectionModifier + + return p +} + +func (s *TypeProjectionModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeProjectionModifierContext) VarianceModifier() IVarianceModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarianceModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarianceModifierContext) +} + +func (s *TypeProjectionModifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeProjectionModifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeProjectionModifierContext) Annotation() IAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *TypeProjectionModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeProjectionModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeProjectionModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeProjectionModifier(s) + } +} + +func (s *TypeProjectionModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeProjectionModifier(s) + } +} + +func (p *KotlinParser) TypeProjectionModifier() (localctx ITypeProjectionModifierContext) { + this := p + _ = this + + localctx = NewTypeProjectionModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, KotlinParserRULE_typeProjectionModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(1769) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserIN, KotlinParserOUT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1761) + p.VarianceModifier() + } + p.SetState(1765) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1762) + p.Match(KotlinParserNL) + } + + p.SetState(1767) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1768) + p.Annotation() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IFunctionTypeContext is an interface to support dynamic dispatch. +type IFunctionTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionTypeContext differentiates from other interfaces. + IsFunctionTypeContext() +} + +type FunctionTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionTypeContext() *FunctionTypeContext { + var p = new(FunctionTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionType + return p +} + +func (*FunctionTypeContext) IsFunctionTypeContext() {} + +func NewFunctionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionTypeContext { + var p = new(FunctionTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionType + + return p +} + +func (s *FunctionTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionTypeContext) FunctionTypeParameters() IFunctionTypeParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionTypeParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionTypeParametersContext) +} + +func (s *FunctionTypeContext) ARROW() antlr.TerminalNode { + return s.GetToken(KotlinParserARROW, 0) +} + +func (s *FunctionTypeContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *FunctionTypeContext) ReceiverType() IReceiverTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReceiverTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReceiverTypeContext) +} + +func (s *FunctionTypeContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *FunctionTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionType(s) + } +} + +func (s *FunctionTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionType(s) + } +} + +func (p *KotlinParser) FunctionType() (localctx IFunctionTypeContext) { + this := p + _ = this + + localctx = NewFunctionTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, KotlinParserRULE_functionType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1785) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 260, p.GetParserRuleContext()) == 1 { + { + p.SetState(1771) + p.ReceiverType() + } + p.SetState(1775) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1772) + p.Match(KotlinParserNL) + } + + p.SetState(1777) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1778) + p.Match(KotlinParserDOT) + } + p.SetState(1782) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1779) + p.Match(KotlinParserNL) + } + + p.SetState(1784) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(1787) + p.FunctionTypeParameters() + } + p.SetState(1791) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1788) + p.Match(KotlinParserNL) + } + + p.SetState(1793) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1794) + p.Match(KotlinParserARROW) + } + p.SetState(1798) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1795) + p.Match(KotlinParserNL) + } + + p.SetState(1800) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1801) + p.Type_() + } + + return localctx +} + +// IFunctionTypeParametersContext is an interface to support dynamic dispatch. +type IFunctionTypeParametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionTypeParametersContext differentiates from other interfaces. + IsFunctionTypeParametersContext() +} + +type FunctionTypeParametersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionTypeParametersContext() *FunctionTypeParametersContext { + var p = new(FunctionTypeParametersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionTypeParameters + return p +} + +func (*FunctionTypeParametersContext) IsFunctionTypeParametersContext() {} + +func NewFunctionTypeParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionTypeParametersContext { + var p = new(FunctionTypeParametersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionTypeParameters + + return p +} + +func (s *FunctionTypeParametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionTypeParametersContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *FunctionTypeParametersContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *FunctionTypeParametersContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FunctionTypeParametersContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FunctionTypeParametersContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *FunctionTypeParametersContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *FunctionTypeParametersContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *FunctionTypeParametersContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *FunctionTypeParametersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *FunctionTypeParametersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *FunctionTypeParametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionTypeParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionTypeParametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionTypeParameters(s) + } +} + +func (s *FunctionTypeParametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionTypeParameters(s) + } +} + +func (p *KotlinParser) FunctionTypeParameters() (localctx IFunctionTypeParametersContext) { + this := p + _ = this + + localctx = NewFunctionTypeParametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, KotlinParserRULE_functionTypeParameters) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1803) + p.Match(KotlinParserLPAREN) + } + p.SetState(1807) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 263, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1804) + p.Match(KotlinParserNL) + } + + } + p.SetState(1809) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 263, p.GetParserRuleContext()) + } + p.SetState(1812) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 264, p.GetParserRuleContext()) == 1 { + { + p.SetState(1810) + p.Parameter() + } + + } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 264, p.GetParserRuleContext()) == 2 { + { + p.SetState(1811) + p.Type_() + } + + } + p.SetState(1833) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 268, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1817) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1814) + p.Match(KotlinParserNL) + } + + p.SetState(1819) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1820) + p.Match(KotlinParserCOMMA) + } + p.SetState(1824) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1821) + p.Match(KotlinParserNL) + } + + p.SetState(1826) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(1829) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 267, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1827) + p.Parameter() + } + + case 2: + { + p.SetState(1828) + p.Type_() + } + + } + + } + p.SetState(1835) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 268, p.GetParserRuleContext()) + } + p.SetState(1843) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 270, p.GetParserRuleContext()) == 1 { + p.SetState(1839) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1836) + p.Match(KotlinParserNL) + } + + p.SetState(1841) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1842) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(1848) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1845) + p.Match(KotlinParserNL) + } + + p.SetState(1850) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1851) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IParenthesizedTypeContext is an interface to support dynamic dispatch. +type IParenthesizedTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParenthesizedTypeContext differentiates from other interfaces. + IsParenthesizedTypeContext() +} + +type ParenthesizedTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesizedTypeContext() *ParenthesizedTypeContext { + var p = new(ParenthesizedTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parenthesizedType + return p +} + +func (*ParenthesizedTypeContext) IsParenthesizedTypeContext() {} + +func NewParenthesizedTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenthesizedTypeContext { + var p = new(ParenthesizedTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parenthesizedType + + return p +} + +func (s *ParenthesizedTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParenthesizedTypeContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ParenthesizedTypeContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *ParenthesizedTypeContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ParenthesizedTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParenthesizedTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParenthesizedTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesizedTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParenthesizedTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParenthesizedType(s) + } +} + +func (s *ParenthesizedTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParenthesizedType(s) + } +} + +func (p *KotlinParser) ParenthesizedType() (localctx IParenthesizedTypeContext) { + this := p + _ = this + + localctx = NewParenthesizedTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, KotlinParserRULE_parenthesizedType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1853) + p.Match(KotlinParserLPAREN) + } + p.SetState(1857) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1854) + p.Match(KotlinParserNL) + } + + p.SetState(1859) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1860) + p.Type_() + } + p.SetState(1864) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1861) + p.Match(KotlinParserNL) + } + + p.SetState(1866) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1867) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IReceiverTypeContext is an interface to support dynamic dispatch. +type IReceiverTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsReceiverTypeContext differentiates from other interfaces. + IsReceiverTypeContext() +} + +type ReceiverTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReceiverTypeContext() *ReceiverTypeContext { + var p = new(ReceiverTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_receiverType + return p +} + +func (*ReceiverTypeContext) IsReceiverTypeContext() {} + +func NewReceiverTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverTypeContext { + var p = new(ReceiverTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_receiverType + + return p +} + +func (s *ReceiverTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReceiverTypeContext) ParenthesizedType() IParenthesizedTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedTypeContext) +} + +func (s *ReceiverTypeContext) NullableType() INullableTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INullableTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INullableTypeContext) +} + +func (s *ReceiverTypeContext) TypeReference() ITypeReferenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeReferenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeReferenceContext) +} + +func (s *ReceiverTypeContext) TypeModifiers() ITypeModifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeModifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeModifiersContext) +} + +func (s *ReceiverTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReceiverTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReceiverTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterReceiverType(s) + } +} + +func (s *ReceiverTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitReceiverType(s) + } +} + +func (p *KotlinParser) ReceiverType() (localctx IReceiverTypeContext) { + this := p + _ = this + + localctx = NewReceiverTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, KotlinParserRULE_receiverType) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1870) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 274, p.GetParserRuleContext()) == 1 { + { + p.SetState(1869) + p.TypeModifiers() + } + + } + p.SetState(1875) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 275, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1872) + p.ParenthesizedType() + } + + case 2: + { + p.SetState(1873) + p.NullableType() + } + + case 3: + { + p.SetState(1874) + p.TypeReference() + } + + } + + return localctx +} + +// IParenthesizedUserTypeContext is an interface to support dynamic dispatch. +type IParenthesizedUserTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParenthesizedUserTypeContext differentiates from other interfaces. + IsParenthesizedUserTypeContext() +} + +type ParenthesizedUserTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesizedUserTypeContext() *ParenthesizedUserTypeContext { + var p = new(ParenthesizedUserTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parenthesizedUserType + return p +} + +func (*ParenthesizedUserTypeContext) IsParenthesizedUserTypeContext() {} + +func NewParenthesizedUserTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenthesizedUserTypeContext { + var p = new(ParenthesizedUserTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parenthesizedUserType + + return p +} + +func (s *ParenthesizedUserTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParenthesizedUserTypeContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ParenthesizedUserTypeContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ParenthesizedUserTypeContext) UserType() IUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *ParenthesizedUserTypeContext) ParenthesizedUserType() IParenthesizedUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedUserTypeContext) +} + +func (s *ParenthesizedUserTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParenthesizedUserTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParenthesizedUserTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesizedUserTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParenthesizedUserTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParenthesizedUserType(s) + } +} + +func (s *ParenthesizedUserTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParenthesizedUserType(s) + } +} + +func (p *KotlinParser) ParenthesizedUserType() (localctx IParenthesizedUserTypeContext) { + this := p + _ = this + + localctx = NewParenthesizedUserTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, KotlinParserRULE_parenthesizedUserType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1877) + p.Match(KotlinParserLPAREN) + } + p.SetState(1881) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1878) + p.Match(KotlinParserNL) + } + + p.SetState(1883) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(1886) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1884) + p.UserType() + } + + case KotlinParserLPAREN: + { + p.SetState(1885) + p.ParenthesizedUserType() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + p.SetState(1891) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1888) + p.Match(KotlinParserNL) + } + + p.SetState(1893) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1894) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IDefinitelyNonNullableTypeContext is an interface to support dynamic dispatch. +type IDefinitelyNonNullableTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDefinitelyNonNullableTypeContext differentiates from other interfaces. + IsDefinitelyNonNullableTypeContext() +} + +type DefinitelyNonNullableTypeContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefinitelyNonNullableTypeContext() *DefinitelyNonNullableTypeContext { + var p = new(DefinitelyNonNullableTypeContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_definitelyNonNullableType + return p +} + +func (*DefinitelyNonNullableTypeContext) IsDefinitelyNonNullableTypeContext() {} + +func NewDefinitelyNonNullableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinitelyNonNullableTypeContext { + var p = new(DefinitelyNonNullableTypeContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_definitelyNonNullableType + + return p +} + +func (s *DefinitelyNonNullableTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefinitelyNonNullableTypeContext) AMP() antlr.TerminalNode { + return s.GetToken(KotlinParserAMP, 0) +} + +func (s *DefinitelyNonNullableTypeContext) AllUserType() []IUserTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUserTypeContext); ok { + len++ + } + } + + tst := make([]IUserTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUserTypeContext); ok { + tst[i] = t.(IUserTypeContext) + i++ + } + } + + return tst +} + +func (s *DefinitelyNonNullableTypeContext) UserType(i int) IUserTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *DefinitelyNonNullableTypeContext) AllParenthesizedUserType() []IParenthesizedUserTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParenthesizedUserTypeContext); ok { + len++ + } + } + + tst := make([]IParenthesizedUserTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParenthesizedUserTypeContext); ok { + tst[i] = t.(IParenthesizedUserTypeContext) + i++ + } + } + + return tst +} + +func (s *DefinitelyNonNullableTypeContext) ParenthesizedUserType(i int) IParenthesizedUserTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedUserTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedUserTypeContext) +} + +func (s *DefinitelyNonNullableTypeContext) AllTypeModifiers() []ITypeModifiersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeModifiersContext); ok { + len++ + } + } + + tst := make([]ITypeModifiersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeModifiersContext); ok { + tst[i] = t.(ITypeModifiersContext) + i++ + } + } + + return tst +} + +func (s *DefinitelyNonNullableTypeContext) TypeModifiers(i int) ITypeModifiersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeModifiersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeModifiersContext) +} + +func (s *DefinitelyNonNullableTypeContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *DefinitelyNonNullableTypeContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *DefinitelyNonNullableTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefinitelyNonNullableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefinitelyNonNullableTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDefinitelyNonNullableType(s) + } +} + +func (s *DefinitelyNonNullableTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDefinitelyNonNullableType(s) + } +} + +func (p *KotlinParser) DefinitelyNonNullableType() (localctx IDefinitelyNonNullableTypeContext) { + this := p + _ = this + + localctx = NewDefinitelyNonNullableTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, KotlinParserRULE_definitelyNonNullableType) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(1897) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 279, p.GetParserRuleContext()) == 1 { + { + p.SetState(1896) + p.TypeModifiers() + } + + } + p.SetState(1901) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1899) + p.UserType() + } + + case KotlinParserLPAREN: + { + p.SetState(1900) + p.ParenthesizedUserType() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + p.SetState(1906) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1903) + p.Match(KotlinParserNL) + } + + p.SetState(1908) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1909) + p.Match(KotlinParserAMP) + } + p.SetState(1913) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1910) + p.Match(KotlinParserNL) + } + + p.SetState(1915) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(1917) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 283, p.GetParserRuleContext()) == 1 { + { + p.SetState(1916) + p.TypeModifiers() + } + + } + p.SetState(1921) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1919) + p.UserType() + } + + case KotlinParserLPAREN: + { + p.SetState(1920) + p.ParenthesizedUserType() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IStatementsContext is an interface to support dynamic dispatch. +type IStatementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsStatementsContext differentiates from other interfaces. + IsStatementsContext() +} + +type StatementsContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementsContext() *StatementsContext { + var p = new(StatementsContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_statements + return p +} + +func (*StatementsContext) IsStatementsContext() {} + +func NewStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementsContext { + var p = new(StatementsContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_statements + + return p +} + +func (s *StatementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementsContext) AllStatement() []IStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementContext); ok { + len++ + } + } + + tst := make([]IStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementContext); ok { + tst[i] = t.(IStatementContext) + i++ + } + } + + return tst +} + +func (s *StatementsContext) Statement(i int) IStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *StatementsContext) AllSemis() []ISemisContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISemisContext); ok { + len++ + } + } + + tst := make([]ISemisContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISemisContext); ok { + tst[i] = t.(ISemisContext) + i++ + } + } + + return tst +} + +func (s *StatementsContext) Semis(i int) ISemisContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemisContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISemisContext) +} + +func (s *StatementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StatementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterStatements(s) + } +} + +func (s *StatementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitStatements(s) + } +} + +func (p *KotlinParser) Statements() (localctx IStatementsContext) { + this := p + _ = this + + localctx = NewStatementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, KotlinParserRULE_statements) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1932) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-144109553024488960) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-4260645306497) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&13629951) != 0 { + { + p.SetState(1923) + p.Statement() + } + p.SetState(1929) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 285, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1924) + p.Semis() + } + { + p.SetState(1925) + p.Statement() + } + + } + p.SetState(1931) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 285, p.GetParserRuleContext()) + } + + } + p.SetState(1935) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 287, p.GetParserRuleContext()) == 1 { + { + p.SetState(1934) + p.Semis() + } + + } + + return localctx +} + +// IStatementContext is an interface to support dynamic dispatch. +type IStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsStatementContext differentiates from other interfaces. + IsStatementContext() +} + +type StatementContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementContext() *StatementContext { + var p = new(StatementContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_statement + return p +} + +func (*StatementContext) IsStatementContext() {} + +func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext { + var p = new(StatementContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_statement + + return p +} + +func (s *StatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementContext) Declaration() IDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclarationContext) +} + +func (s *StatementContext) Assignment() IAssignmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentContext) +} + +func (s *StatementContext) LoopStatement() ILoopStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoopStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoopStatementContext) +} + +func (s *StatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *StatementContext) AllLabel() []ILabelContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabelContext); ok { + len++ + } + } + + tst := make([]ILabelContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabelContext); ok { + tst[i] = t.(ILabelContext) + i++ + } + } + + return tst +} + +func (s *StatementContext) Label(i int) ILabelContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabelContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabelContext) +} + +func (s *StatementContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *StatementContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *StatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterStatement(s) + } +} + +func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitStatement(s) + } +} + +func (p *KotlinParser) Statement() (localctx IStatementContext) { + this := p + _ = this + + localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, KotlinParserRULE_statement) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1941) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 289, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(1939) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1937) + p.Label() + } + + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + { + p.SetState(1938) + p.Annotation() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + } + p.SetState(1943) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 289, p.GetParserRuleContext()) + } + p.SetState(1948) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 290, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1944) + p.Declaration() + } + + case 2: + { + p.SetState(1945) + p.Assignment() + } + + case 3: + { + p.SetState(1946) + p.LoopStatement() + } + + case 4: + { + p.SetState(1947) + p.Expression() + } + + } + + return localctx +} + +// ILabelContext is an interface to support dynamic dispatch. +type ILabelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLabelContext differentiates from other interfaces. + IsLabelContext() +} + +type LabelContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabelContext() *LabelContext { + var p = new(LabelContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_label + return p +} + +func (*LabelContext) IsLabelContext() {} + +func NewLabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabelContext { + var p = new(LabelContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_label + + return p +} + +func (s *LabelContext) GetParser() antlr.Parser { return s.parser } + +func (s *LabelContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *LabelContext) AT_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_NO_WS, 0) +} + +func (s *LabelContext) AT_POST_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_POST_WS, 0) +} + +func (s *LabelContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *LabelContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *LabelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LabelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLabel(s) + } +} + +func (s *LabelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLabel(s) + } +} + +func (p *KotlinParser) Label() (localctx ILabelContext) { + this := p + _ = this + + localctx = NewLabelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, KotlinParserRULE_label) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1950) + p.SimpleIdentifier() + } + { + p.SetState(1951) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserAT_NO_WS || _la == KotlinParserAT_POST_WS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1955) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 291, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1952) + p.Match(KotlinParserNL) + } + + } + p.SetState(1957) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 291, p.GetParserRuleContext()) + } + + return localctx +} + +// IControlStructureBodyContext is an interface to support dynamic dispatch. +type IControlStructureBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsControlStructureBodyContext differentiates from other interfaces. + IsControlStructureBodyContext() +} + +type ControlStructureBodyContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyControlStructureBodyContext() *ControlStructureBodyContext { + var p = new(ControlStructureBodyContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_controlStructureBody + return p +} + +func (*ControlStructureBodyContext) IsControlStructureBodyContext() {} + +func NewControlStructureBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ControlStructureBodyContext { + var p = new(ControlStructureBodyContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_controlStructureBody + + return p +} + +func (s *ControlStructureBodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *ControlStructureBodyContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *ControlStructureBodyContext) Statement() IStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *ControlStructureBodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ControlStructureBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ControlStructureBodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterControlStructureBody(s) + } +} + +func (s *ControlStructureBodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitControlStructureBody(s) + } +} + +func (p *KotlinParser) ControlStructureBody() (localctx IControlStructureBodyContext) { + this := p + _ = this + + localctx = NewControlStructureBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, KotlinParserRULE_controlStructureBody) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(1960) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 292, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1958) + p.Block() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1959) + p.Statement() + } + + } + + return localctx +} + +// IBlockContext is an interface to support dynamic dispatch. +type IBlockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsBlockContext differentiates from other interfaces. + IsBlockContext() +} + +type BlockContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockContext() *BlockContext { + var p = new(BlockContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_block + return p +} + +func (*BlockContext) IsBlockContext() {} + +func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext { + var p = new(BlockContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_block + + return p +} + +func (s *BlockContext) GetParser() antlr.Parser { return s.parser } + +func (s *BlockContext) LCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserLCURL, 0) +} + +func (s *BlockContext) Statements() IStatementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementsContext) +} + +func (s *BlockContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *BlockContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *BlockContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *BlockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BlockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterBlock(s) + } +} + +func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitBlock(s) + } +} + +func (p *KotlinParser) Block() (localctx IBlockContext) { + this := p + _ = this + + localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, KotlinParserRULE_block) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1962) + p.Match(KotlinParserLCURL) + } + p.SetState(1966) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 293, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1963) + p.Match(KotlinParserNL) + } + + } + p.SetState(1968) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 293, p.GetParserRuleContext()) + } + { + p.SetState(1969) + p.Statements() + } + p.SetState(1973) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1970) + p.Match(KotlinParserNL) + } + + p.SetState(1975) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1976) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// ILoopStatementContext is an interface to support dynamic dispatch. +type ILoopStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLoopStatementContext differentiates from other interfaces. + IsLoopStatementContext() +} + +type LoopStatementContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoopStatementContext() *LoopStatementContext { + var p = new(LoopStatementContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_loopStatement + return p +} + +func (*LoopStatementContext) IsLoopStatementContext() {} + +func NewLoopStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoopStatementContext { + var p = new(LoopStatementContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_loopStatement + + return p +} + +func (s *LoopStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoopStatementContext) ForStatement() IForStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForStatementContext) +} + +func (s *LoopStatementContext) WhileStatement() IWhileStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhileStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhileStatementContext) +} + +func (s *LoopStatementContext) DoWhileStatement() IDoWhileStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDoWhileStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDoWhileStatementContext) +} + +func (s *LoopStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoopStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoopStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLoopStatement(s) + } +} + +func (s *LoopStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLoopStatement(s) + } +} + +func (p *KotlinParser) LoopStatement() (localctx ILoopStatementContext) { + this := p + _ = this + + localctx = NewLoopStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, KotlinParserRULE_loopStatement) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(1981) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1978) + p.ForStatement() + } + + case KotlinParserWHILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1979) + p.WhileStatement() + } + + case KotlinParserDO: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1980) + p.DoWhileStatement() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IForStatementContext is an interface to support dynamic dispatch. +type IForStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsForStatementContext differentiates from other interfaces. + IsForStatementContext() +} + +type ForStatementContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForStatementContext() *ForStatementContext { + var p = new(ForStatementContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_forStatement + return p +} + +func (*ForStatementContext) IsForStatementContext() {} + +func NewForStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStatementContext { + var p = new(ForStatementContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_forStatement + + return p +} + +func (s *ForStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ForStatementContext) FOR() antlr.TerminalNode { + return s.GetToken(KotlinParserFOR, 0) +} + +func (s *ForStatementContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ForStatementContext) IN() antlr.TerminalNode { + return s.GetToken(KotlinParserIN, 0) +} + +func (s *ForStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ForStatementContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ForStatementContext) VariableDeclaration() IVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableDeclarationContext) +} + +func (s *ForStatementContext) MultiVariableDeclaration() IMultiVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiVariableDeclarationContext) +} + +func (s *ForStatementContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ForStatementContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ForStatementContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *ForStatementContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *ForStatementContext) ControlStructureBody() IControlStructureBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlStructureBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IControlStructureBodyContext) +} + +func (s *ForStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ForStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ForStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterForStatement(s) + } +} + +func (s *ForStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitForStatement(s) + } +} + +func (p *KotlinParser) ForStatement() (localctx IForStatementContext) { + this := p + _ = this + + localctx = NewForStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, KotlinParserRULE_forStatement) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1983) + p.Match(KotlinParserFOR) + } + p.SetState(1987) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(1984) + p.Match(KotlinParserNL) + } + + p.SetState(1989) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1990) + p.Match(KotlinParserLPAREN) + } + p.SetState(1994) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 297, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1991) + p.Annotation() + } + + } + p.SetState(1996) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 297, p.GetParserRuleContext()) + } + p.SetState(1999) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserNL, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(1997) + p.VariableDeclaration() + } + + case KotlinParserLPAREN: + { + p.SetState(1998) + p.MultiVariableDeclaration() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + { + p.SetState(2001) + p.Match(KotlinParserIN) + } + { + p.SetState(2002) + p.Expression() + } + { + p.SetState(2003) + p.Match(KotlinParserRPAREN) + } + p.SetState(2007) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 299, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2004) + p.Match(KotlinParserNL) + } + + } + p.SetState(2009) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 299, p.GetParserRuleContext()) + } + p.SetState(2011) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 300, p.GetParserRuleContext()) == 1 { + { + p.SetState(2010) + p.ControlStructureBody() + } + + } + + return localctx +} + +// IWhileStatementContext is an interface to support dynamic dispatch. +type IWhileStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsWhileStatementContext differentiates from other interfaces. + IsWhileStatementContext() +} + +type WhileStatementContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhileStatementContext() *WhileStatementContext { + var p = new(WhileStatementContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_whileStatement + return p +} + +func (*WhileStatementContext) IsWhileStatementContext() {} + +func NewWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementContext { + var p = new(WhileStatementContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_whileStatement + + return p +} + +func (s *WhileStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhileStatementContext) WHILE() antlr.TerminalNode { + return s.GetToken(KotlinParserWHILE, 0) +} + +func (s *WhileStatementContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *WhileStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WhileStatementContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *WhileStatementContext) ControlStructureBody() IControlStructureBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlStructureBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IControlStructureBodyContext) +} + +func (s *WhileStatementContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(KotlinParserSEMICOLON, 0) +} + +func (s *WhileStatementContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *WhileStatementContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhileStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhileStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterWhileStatement(s) + } +} + +func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitWhileStatement(s) + } +} + +func (p *KotlinParser) WhileStatement() (localctx IWhileStatementContext) { + this := p + _ = this + + localctx = NewWhileStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, KotlinParserRULE_whileStatement) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2013) + p.Match(KotlinParserWHILE) + } + p.SetState(2017) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2014) + p.Match(KotlinParserNL) + } + + p.SetState(2019) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2020) + p.Match(KotlinParserLPAREN) + } + { + p.SetState(2021) + p.Expression() + } + { + p.SetState(2022) + p.Match(KotlinParserRPAREN) + } + p.SetState(2026) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2023) + p.Match(KotlinParserNL) + } + + p.SetState(2028) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(2031) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLPAREN, KotlinParserLSQUARE, KotlinParserLCURL, KotlinParserADD, KotlinParserSUB, KotlinParserINCR, KotlinParserDECR, KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS, KotlinParserCOLONCOLON, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserRETURN_AT, KotlinParserCONTINUE_AT, KotlinParserBREAK_AT, KotlinParserTHIS_AT, KotlinParserSUPER_AT, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCLASS, KotlinParserINTERFACE, KotlinParserFUN, KotlinParserOBJECT, KotlinParserVAL, KotlinParserVAR, KotlinParserTYPE_ALIAS, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserTHIS, KotlinParserSUPER, KotlinParserWHERE, KotlinParserIF, KotlinParserWHEN, KotlinParserTRY, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserFOR, KotlinParserDO, KotlinParserWHILE, KotlinParserTHROW, KotlinParserRETURN, KotlinParserCONTINUE, KotlinParserBREAK, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserRealLiteral, KotlinParserIntegerLiteral, KotlinParserHexLiteral, KotlinParserBinLiteral, KotlinParserUnsignedLiteral, KotlinParserLongLiteral, KotlinParserBooleanLiteral, KotlinParserNullLiteral, KotlinParserCharacterLiteral, KotlinParserIdentifier, KotlinParserQUOTE_OPEN, KotlinParserTRIPLE_QUOTE_OPEN: + { + p.SetState(2029) + p.ControlStructureBody() + } + + case KotlinParserSEMICOLON: + { + p.SetState(2030) + p.Match(KotlinParserSEMICOLON) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IDoWhileStatementContext is an interface to support dynamic dispatch. +type IDoWhileStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDoWhileStatementContext differentiates from other interfaces. + IsDoWhileStatementContext() +} + +type DoWhileStatementContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDoWhileStatementContext() *DoWhileStatementContext { + var p = new(DoWhileStatementContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_doWhileStatement + return p +} + +func (*DoWhileStatementContext) IsDoWhileStatementContext() {} + +func NewDoWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoWhileStatementContext { + var p = new(DoWhileStatementContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_doWhileStatement + + return p +} + +func (s *DoWhileStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *DoWhileStatementContext) DO() antlr.TerminalNode { + return s.GetToken(KotlinParserDO, 0) +} + +func (s *DoWhileStatementContext) WHILE() antlr.TerminalNode { + return s.GetToken(KotlinParserWHILE, 0) +} + +func (s *DoWhileStatementContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *DoWhileStatementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DoWhileStatementContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *DoWhileStatementContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *DoWhileStatementContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *DoWhileStatementContext) ControlStructureBody() IControlStructureBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlStructureBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IControlStructureBodyContext) +} + +func (s *DoWhileStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DoWhileStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DoWhileStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDoWhileStatement(s) + } +} + +func (s *DoWhileStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDoWhileStatement(s) + } +} + +func (p *KotlinParser) DoWhileStatement() (localctx IDoWhileStatementContext) { + this := p + _ = this + + localctx = NewDoWhileStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, KotlinParserRULE_doWhileStatement) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2033) + p.Match(KotlinParserDO) + } + p.SetState(2037) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 304, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2034) + p.Match(KotlinParserNL) + } + + } + p.SetState(2039) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 304, p.GetParserRuleContext()) + } + p.SetState(2041) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 305, p.GetParserRuleContext()) == 1 { + { + p.SetState(2040) + p.ControlStructureBody() + } + + } + p.SetState(2046) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2043) + p.Match(KotlinParserNL) + } + + p.SetState(2048) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2049) + p.Match(KotlinParserWHILE) + } + p.SetState(2053) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2050) + p.Match(KotlinParserNL) + } + + p.SetState(2055) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2056) + p.Match(KotlinParserLPAREN) + } + { + p.SetState(2057) + p.Expression() + } + { + p.SetState(2058) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IAssignmentContext is an interface to support dynamic dispatch. +type IAssignmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAssignmentContext differentiates from other interfaces. + IsAssignmentContext() +} + +type AssignmentContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentContext() *AssignmentContext { + var p = new(AssignmentContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_assignment + return p +} + +func (*AssignmentContext) IsAssignmentContext() {} + +func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext { + var p = new(AssignmentContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_assignment + + return p +} + +func (s *AssignmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *AssignmentContext) DirectlyAssignableExpression() IDirectlyAssignableExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectlyAssignableExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectlyAssignableExpressionContext) +} + +func (s *AssignmentContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *AssignmentContext) AssignableExpression() IAssignableExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignableExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignableExpressionContext) +} + +func (s *AssignmentContext) AssignmentAndOperator() IAssignmentAndOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentAndOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentAndOperatorContext) +} + +func (s *AssignmentContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AssignmentContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AssignmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAssignment(s) + } +} + +func (s *AssignmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAssignment(s) + } +} + +func (p *KotlinParser) Assignment() (localctx IAssignmentContext) { + this := p + _ = this + + localctx = NewAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, KotlinParserRULE_assignment) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(2066) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 308, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2060) + p.DirectlyAssignableExpression() + } + { + p.SetState(2061) + p.Match(KotlinParserASSIGNMENT) + } + + case 2: + { + p.SetState(2063) + p.AssignableExpression() + } + { + p.SetState(2064) + p.AssignmentAndOperator() + } + + } + p.SetState(2071) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2068) + p.Match(KotlinParserNL) + } + + p.SetState(2073) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2074) + p.Expression() + } + + return localctx +} + +// ISemiContext is an interface to support dynamic dispatch. +type ISemiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSemiContext differentiates from other interfaces. + IsSemiContext() +} + +type SemiContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySemiContext() *SemiContext { + var p = new(SemiContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_semi + return p +} + +func (*SemiContext) IsSemiContext() {} + +func NewSemiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SemiContext { + var p = new(SemiContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_semi + + return p +} + +func (s *SemiContext) GetParser() antlr.Parser { return s.parser } + +func (s *SemiContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(KotlinParserSEMICOLON, 0) +} + +func (s *SemiContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SemiContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SemiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SemiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SemiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSemi(s) + } +} + +func (s *SemiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSemi(s) + } +} + +func (p *KotlinParser) Semi() (localctx ISemiContext) { + this := p + _ = this + + localctx = NewSemiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, KotlinParserRULE_semi) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2076) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserNL || _la == KotlinParserSEMICOLON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2080) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 310, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2077) + p.Match(KotlinParserNL) + } + + } + p.SetState(2082) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 310, p.GetParserRuleContext()) + } + + return localctx +} + +// ISemisContext is an interface to support dynamic dispatch. +type ISemisContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSemisContext differentiates from other interfaces. + IsSemisContext() +} + +type SemisContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySemisContext() *SemisContext { + var p = new(SemisContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_semis + return p +} + +func (*SemisContext) IsSemisContext() {} + +func NewSemisContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SemisContext { + var p = new(SemisContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_semis + + return p +} + +func (s *SemisContext) GetParser() antlr.Parser { return s.parser } + +func (s *SemisContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(KotlinParserSEMICOLON) +} + +func (s *SemisContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserSEMICOLON, i) +} + +func (s *SemisContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SemisContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SemisContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SemisContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SemisContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSemis(s) + } +} + +func (s *SemisContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSemis(s) + } +} + +func (p *KotlinParser) Semis() (localctx ISemisContext) { + this := p + _ = this + + localctx = NewSemisContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, KotlinParserRULE_semis) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2084) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(2083) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserNL || _la == KotlinParserSEMICOLON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(2086) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 311, p.GetParserRuleContext()) + } + + return localctx +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_expression + return p +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) Disjunction() IDisjunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisjunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisjunctionContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (p *KotlinParser) Expression() (localctx IExpressionContext) { + this := p + _ = this + + localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, KotlinParserRULE_expression) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2088) + p.Disjunction() + } + + return localctx +} + +// IDisjunctionContext is an interface to support dynamic dispatch. +type IDisjunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDisjunctionContext differentiates from other interfaces. + IsDisjunctionContext() +} + +type DisjunctionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisjunctionContext() *DisjunctionContext { + var p = new(DisjunctionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_disjunction + return p +} + +func (*DisjunctionContext) IsDisjunctionContext() {} + +func NewDisjunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DisjunctionContext { + var p = new(DisjunctionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_disjunction + + return p +} + +func (s *DisjunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DisjunctionContext) AllConjunction() []IConjunctionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConjunctionContext); ok { + len++ + } + } + + tst := make([]IConjunctionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConjunctionContext); ok { + tst[i] = t.(IConjunctionContext) + i++ + } + } + + return tst +} + +func (s *DisjunctionContext) Conjunction(i int) IConjunctionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConjunctionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConjunctionContext) +} + +func (s *DisjunctionContext) AllDISJ() []antlr.TerminalNode { + return s.GetTokens(KotlinParserDISJ) +} + +func (s *DisjunctionContext) DISJ(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserDISJ, i) +} + +func (s *DisjunctionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *DisjunctionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *DisjunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DisjunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DisjunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDisjunction(s) + } +} + +func (s *DisjunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDisjunction(s) + } +} + +func (p *KotlinParser) Disjunction() (localctx IDisjunctionContext) { + this := p + _ = this + + localctx = NewDisjunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, KotlinParserRULE_disjunction) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2090) + p.Conjunction() + } + p.SetState(2107) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 314, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2094) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2091) + p.Match(KotlinParserNL) + } + + p.SetState(2096) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2097) + p.Match(KotlinParserDISJ) + } + p.SetState(2101) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2098) + p.Match(KotlinParserNL) + } + + p.SetState(2103) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2104) + p.Conjunction() + } + + } + p.SetState(2109) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 314, p.GetParserRuleContext()) + } + + return localctx +} + +// IConjunctionContext is an interface to support dynamic dispatch. +type IConjunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsConjunctionContext differentiates from other interfaces. + IsConjunctionContext() +} + +type ConjunctionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConjunctionContext() *ConjunctionContext { + var p = new(ConjunctionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_conjunction + return p +} + +func (*ConjunctionContext) IsConjunctionContext() {} + +func NewConjunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConjunctionContext { + var p = new(ConjunctionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_conjunction + + return p +} + +func (s *ConjunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConjunctionContext) AllEquality() []IEqualityContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEqualityContext); ok { + len++ + } + } + + tst := make([]IEqualityContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEqualityContext); ok { + tst[i] = t.(IEqualityContext) + i++ + } + } + + return tst +} + +func (s *ConjunctionContext) Equality(i int) IEqualityContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEqualityContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEqualityContext) +} + +func (s *ConjunctionContext) AllCONJ() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCONJ) +} + +func (s *ConjunctionContext) CONJ(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCONJ, i) +} + +func (s *ConjunctionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ConjunctionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ConjunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConjunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConjunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterConjunction(s) + } +} + +func (s *ConjunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitConjunction(s) + } +} + +func (p *KotlinParser) Conjunction() (localctx IConjunctionContext) { + this := p + _ = this + + localctx = NewConjunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, KotlinParserRULE_conjunction) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2110) + p.Equality() + } + p.SetState(2127) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 317, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2114) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2111) + p.Match(KotlinParserNL) + } + + p.SetState(2116) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2117) + p.Match(KotlinParserCONJ) + } + p.SetState(2121) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2118) + p.Match(KotlinParserNL) + } + + p.SetState(2123) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2124) + p.Equality() + } + + } + p.SetState(2129) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 317, p.GetParserRuleContext()) + } + + return localctx +} + +// IEqualityContext is an interface to support dynamic dispatch. +type IEqualityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsEqualityContext differentiates from other interfaces. + IsEqualityContext() +} + +type EqualityContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEqualityContext() *EqualityContext { + var p = new(EqualityContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_equality + return p +} + +func (*EqualityContext) IsEqualityContext() {} + +func NewEqualityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityContext { + var p = new(EqualityContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_equality + + return p +} + +func (s *EqualityContext) GetParser() antlr.Parser { return s.parser } + +func (s *EqualityContext) AllComparison() []IComparisonContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComparisonContext); ok { + len++ + } + } + + tst := make([]IComparisonContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComparisonContext); ok { + tst[i] = t.(IComparisonContext) + i++ + } + } + + return tst +} + +func (s *EqualityContext) Comparison(i int) IComparisonContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComparisonContext) +} + +func (s *EqualityContext) AllEqualityOperator() []IEqualityOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEqualityOperatorContext); ok { + len++ + } + } + + tst := make([]IEqualityOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEqualityOperatorContext); ok { + tst[i] = t.(IEqualityOperatorContext) + i++ + } + } + + return tst +} + +func (s *EqualityContext) EqualityOperator(i int) IEqualityOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEqualityOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEqualityOperatorContext) +} + +func (s *EqualityContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *EqualityContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *EqualityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EqualityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EqualityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterEquality(s) + } +} + +func (s *EqualityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitEquality(s) + } +} + +func (p *KotlinParser) Equality() (localctx IEqualityContext) { + this := p + _ = this + + localctx = NewEqualityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, KotlinParserRULE_equality) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2130) + p.Comparison() + } + p.SetState(2142) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 319, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2131) + p.EqualityOperator() + } + p.SetState(2135) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2132) + p.Match(KotlinParserNL) + } + + p.SetState(2137) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2138) + p.Comparison() + } + + } + p.SetState(2144) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 319, p.GetParserRuleContext()) + } + + return localctx +} + +// IComparisonContext is an interface to support dynamic dispatch. +type IComparisonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsComparisonContext differentiates from other interfaces. + IsComparisonContext() +} + +type ComparisonContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparisonContext() *ComparisonContext { + var p = new(ComparisonContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_comparison + return p +} + +func (*ComparisonContext) IsComparisonContext() {} + +func NewComparisonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonContext { + var p = new(ComparisonContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_comparison + + return p +} + +func (s *ComparisonContext) GetParser() antlr.Parser { return s.parser } + +func (s *ComparisonContext) AllGenericCallLikeComparison() []IGenericCallLikeComparisonContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGenericCallLikeComparisonContext); ok { + len++ + } + } + + tst := make([]IGenericCallLikeComparisonContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGenericCallLikeComparisonContext); ok { + tst[i] = t.(IGenericCallLikeComparisonContext) + i++ + } + } + + return tst +} + +func (s *ComparisonContext) GenericCallLikeComparison(i int) IGenericCallLikeComparisonContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenericCallLikeComparisonContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGenericCallLikeComparisonContext) +} + +func (s *ComparisonContext) AllComparisonOperator() []IComparisonOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComparisonOperatorContext); ok { + len++ + } + } + + tst := make([]IComparisonOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComparisonOperatorContext); ok { + tst[i] = t.(IComparisonOperatorContext) + i++ + } + } + + return tst +} + +func (s *ComparisonContext) ComparisonOperator(i int) IComparisonOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComparisonOperatorContext) +} + +func (s *ComparisonContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ComparisonContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ComparisonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComparisonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ComparisonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterComparison(s) + } +} + +func (s *ComparisonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitComparison(s) + } +} + +func (p *KotlinParser) Comparison() (localctx IComparisonContext) { + this := p + _ = this + + localctx = NewComparisonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, KotlinParserRULE_comparison) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2145) + p.GenericCallLikeComparison() + } + p.SetState(2157) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 321, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2146) + p.ComparisonOperator() + } + p.SetState(2150) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2147) + p.Match(KotlinParserNL) + } + + p.SetState(2152) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2153) + p.GenericCallLikeComparison() + } + + } + p.SetState(2159) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 321, p.GetParserRuleContext()) + } + + return localctx +} + +// IGenericCallLikeComparisonContext is an interface to support dynamic dispatch. +type IGenericCallLikeComparisonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsGenericCallLikeComparisonContext differentiates from other interfaces. + IsGenericCallLikeComparisonContext() +} + +type GenericCallLikeComparisonContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGenericCallLikeComparisonContext() *GenericCallLikeComparisonContext { + var p = new(GenericCallLikeComparisonContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_genericCallLikeComparison + return p +} + +func (*GenericCallLikeComparisonContext) IsGenericCallLikeComparisonContext() {} + +func NewGenericCallLikeComparisonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenericCallLikeComparisonContext { + var p = new(GenericCallLikeComparisonContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_genericCallLikeComparison + + return p +} + +func (s *GenericCallLikeComparisonContext) GetParser() antlr.Parser { return s.parser } + +func (s *GenericCallLikeComparisonContext) InfixOperation() IInfixOperationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInfixOperationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInfixOperationContext) +} + +func (s *GenericCallLikeComparisonContext) AllCallSuffix() []ICallSuffixContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICallSuffixContext); ok { + len++ + } + } + + tst := make([]ICallSuffixContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICallSuffixContext); ok { + tst[i] = t.(ICallSuffixContext) + i++ + } + } + + return tst +} + +func (s *GenericCallLikeComparisonContext) CallSuffix(i int) ICallSuffixContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallSuffixContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICallSuffixContext) +} + +func (s *GenericCallLikeComparisonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GenericCallLikeComparisonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GenericCallLikeComparisonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterGenericCallLikeComparison(s) + } +} + +func (s *GenericCallLikeComparisonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitGenericCallLikeComparison(s) + } +} + +func (p *KotlinParser) GenericCallLikeComparison() (localctx IGenericCallLikeComparisonContext) { + this := p + _ = this + + localctx = NewGenericCallLikeComparisonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, KotlinParserRULE_genericCallLikeComparison) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2160) + p.InfixOperation() + } + p.SetState(2164) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 322, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2161) + p.CallSuffix() + } + + } + p.SetState(2166) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 322, p.GetParserRuleContext()) + } + + return localctx +} + +// IInfixOperationContext is an interface to support dynamic dispatch. +type IInfixOperationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsInfixOperationContext differentiates from other interfaces. + IsInfixOperationContext() +} + +type InfixOperationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInfixOperationContext() *InfixOperationContext { + var p = new(InfixOperationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_infixOperation + return p +} + +func (*InfixOperationContext) IsInfixOperationContext() {} + +func NewInfixOperationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InfixOperationContext { + var p = new(InfixOperationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_infixOperation + + return p +} + +func (s *InfixOperationContext) GetParser() antlr.Parser { return s.parser } + +func (s *InfixOperationContext) AllElvisExpression() []IElvisExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElvisExpressionContext); ok { + len++ + } + } + + tst := make([]IElvisExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElvisExpressionContext); ok { + tst[i] = t.(IElvisExpressionContext) + i++ + } + } + + return tst +} + +func (s *InfixOperationContext) ElvisExpression(i int) IElvisExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElvisExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElvisExpressionContext) +} + +func (s *InfixOperationContext) AllInOperator() []IInOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInOperatorContext); ok { + len++ + } + } + + tst := make([]IInOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInOperatorContext); ok { + tst[i] = t.(IInOperatorContext) + i++ + } + } + + return tst +} + +func (s *InfixOperationContext) InOperator(i int) IInOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInOperatorContext) +} + +func (s *InfixOperationContext) AllIsOperator() []IIsOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIsOperatorContext); ok { + len++ + } + } + + tst := make([]IIsOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIsOperatorContext); ok { + tst[i] = t.(IIsOperatorContext) + i++ + } + } + + return tst +} + +func (s *InfixOperationContext) IsOperator(i int) IIsOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIsOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIsOperatorContext) +} + +func (s *InfixOperationContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *InfixOperationContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *InfixOperationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *InfixOperationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *InfixOperationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InfixOperationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InfixOperationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterInfixOperation(s) + } +} + +func (s *InfixOperationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitInfixOperation(s) + } +} + +func (p *KotlinParser) InfixOperation() (localctx IInfixOperationContext) { + this := p + _ = this + + localctx = NewInfixOperationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, KotlinParserRULE_infixOperation) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2167) + p.ElvisExpression() + } + p.SetState(2188) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 326, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2186) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserIN, KotlinParserNOT_IN: + { + p.SetState(2168) + p.InOperator() + } + p.SetState(2172) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2169) + p.Match(KotlinParserNL) + } + + p.SetState(2174) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2175) + p.ElvisExpression() + } + + case KotlinParserIS, KotlinParserNOT_IS: + { + p.SetState(2177) + p.IsOperator() + } + p.SetState(2181) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2178) + p.Match(KotlinParserNL) + } + + p.SetState(2183) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2184) + p.Type_() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + } + p.SetState(2190) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 326, p.GetParserRuleContext()) + } + + return localctx +} + +// IElvisExpressionContext is an interface to support dynamic dispatch. +type IElvisExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsElvisExpressionContext differentiates from other interfaces. + IsElvisExpressionContext() +} + +type ElvisExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElvisExpressionContext() *ElvisExpressionContext { + var p = new(ElvisExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_elvisExpression + return p +} + +func (*ElvisExpressionContext) IsElvisExpressionContext() {} + +func NewElvisExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElvisExpressionContext { + var p = new(ElvisExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_elvisExpression + + return p +} + +func (s *ElvisExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ElvisExpressionContext) AllInfixFunctionCall() []IInfixFunctionCallContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInfixFunctionCallContext); ok { + len++ + } + } + + tst := make([]IInfixFunctionCallContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInfixFunctionCallContext); ok { + tst[i] = t.(IInfixFunctionCallContext) + i++ + } + } + + return tst +} + +func (s *ElvisExpressionContext) InfixFunctionCall(i int) IInfixFunctionCallContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInfixFunctionCallContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInfixFunctionCallContext) +} + +func (s *ElvisExpressionContext) AllElvis() []IElvisContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElvisContext); ok { + len++ + } + } + + tst := make([]IElvisContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElvisContext); ok { + tst[i] = t.(IElvisContext) + i++ + } + } + + return tst +} + +func (s *ElvisExpressionContext) Elvis(i int) IElvisContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElvisContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElvisContext) +} + +func (s *ElvisExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ElvisExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ElvisExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ElvisExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ElvisExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterElvisExpression(s) + } +} + +func (s *ElvisExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitElvisExpression(s) + } +} + +func (p *KotlinParser) ElvisExpression() (localctx IElvisExpressionContext) { + this := p + _ = this + + localctx = NewElvisExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, KotlinParserRULE_elvisExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2191) + p.InfixFunctionCall() + } + p.SetState(2209) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 329, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2195) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2192) + p.Match(KotlinParserNL) + } + + p.SetState(2197) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2198) + p.Elvis() + } + p.SetState(2202) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2199) + p.Match(KotlinParserNL) + } + + p.SetState(2204) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2205) + p.InfixFunctionCall() + } + + } + p.SetState(2211) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 329, p.GetParserRuleContext()) + } + + return localctx +} + +// IElvisContext is an interface to support dynamic dispatch. +type IElvisContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsElvisContext differentiates from other interfaces. + IsElvisContext() +} + +type ElvisContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElvisContext() *ElvisContext { + var p = new(ElvisContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_elvis + return p +} + +func (*ElvisContext) IsElvisContext() {} + +func NewElvisContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElvisContext { + var p = new(ElvisContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_elvis + + return p +} + +func (s *ElvisContext) GetParser() antlr.Parser { return s.parser } + +func (s *ElvisContext) QUEST_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserQUEST_NO_WS, 0) +} + +func (s *ElvisContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ElvisContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ElvisContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ElvisContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterElvis(s) + } +} + +func (s *ElvisContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitElvis(s) + } +} + +func (p *KotlinParser) Elvis() (localctx IElvisContext) { + this := p + _ = this + + localctx = NewElvisContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, KotlinParserRULE_elvis) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2212) + p.Match(KotlinParserQUEST_NO_WS) + } + { + p.SetState(2213) + p.Match(KotlinParserCOLON) + } + + return localctx +} + +// IInfixFunctionCallContext is an interface to support dynamic dispatch. +type IInfixFunctionCallContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsInfixFunctionCallContext differentiates from other interfaces. + IsInfixFunctionCallContext() +} + +type InfixFunctionCallContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInfixFunctionCallContext() *InfixFunctionCallContext { + var p = new(InfixFunctionCallContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_infixFunctionCall + return p +} + +func (*InfixFunctionCallContext) IsInfixFunctionCallContext() {} + +func NewInfixFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InfixFunctionCallContext { + var p = new(InfixFunctionCallContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_infixFunctionCall + + return p +} + +func (s *InfixFunctionCallContext) GetParser() antlr.Parser { return s.parser } + +func (s *InfixFunctionCallContext) AllRangeExpression() []IRangeExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRangeExpressionContext); ok { + len++ + } + } + + tst := make([]IRangeExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRangeExpressionContext); ok { + tst[i] = t.(IRangeExpressionContext) + i++ + } + } + + return tst +} + +func (s *InfixFunctionCallContext) RangeExpression(i int) IRangeExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRangeExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRangeExpressionContext) +} + +func (s *InfixFunctionCallContext) AllSimpleIdentifier() []ISimpleIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + len++ + } + } + + tst := make([]ISimpleIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimpleIdentifierContext); ok { + tst[i] = t.(ISimpleIdentifierContext) + i++ + } + } + + return tst +} + +func (s *InfixFunctionCallContext) SimpleIdentifier(i int) ISimpleIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *InfixFunctionCallContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *InfixFunctionCallContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *InfixFunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InfixFunctionCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InfixFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterInfixFunctionCall(s) + } +} + +func (s *InfixFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitInfixFunctionCall(s) + } +} + +func (p *KotlinParser) InfixFunctionCall() (localctx IInfixFunctionCallContext) { + this := p + _ = this + + localctx = NewInfixFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, KotlinParserRULE_infixFunctionCall) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2215) + p.RangeExpression() + } + p.SetState(2227) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 331, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2216) + p.SimpleIdentifier() + } + p.SetState(2220) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2217) + p.Match(KotlinParserNL) + } + + p.SetState(2222) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2223) + p.RangeExpression() + } + + } + p.SetState(2229) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 331, p.GetParserRuleContext()) + } + + return localctx +} + +// IRangeExpressionContext is an interface to support dynamic dispatch. +type IRangeExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsRangeExpressionContext differentiates from other interfaces. + IsRangeExpressionContext() +} + +type RangeExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRangeExpressionContext() *RangeExpressionContext { + var p = new(RangeExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_rangeExpression + return p +} + +func (*RangeExpressionContext) IsRangeExpressionContext() {} + +func NewRangeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeExpressionContext { + var p = new(RangeExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_rangeExpression + + return p +} + +func (s *RangeExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RangeExpressionContext) AllAdditiveExpression() []IAdditiveExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdditiveExpressionContext); ok { + len++ + } + } + + tst := make([]IAdditiveExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdditiveExpressionContext); ok { + tst[i] = t.(IAdditiveExpressionContext) + i++ + } + } + + return tst +} + +func (s *RangeExpressionContext) AdditiveExpression(i int) IAdditiveExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdditiveExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdditiveExpressionContext) +} + +func (s *RangeExpressionContext) AllRANGE() []antlr.TerminalNode { + return s.GetTokens(KotlinParserRANGE) +} + +func (s *RangeExpressionContext) RANGE(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserRANGE, i) +} + +func (s *RangeExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *RangeExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *RangeExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RangeExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RangeExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterRangeExpression(s) + } +} + +func (s *RangeExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitRangeExpression(s) + } +} + +func (p *KotlinParser) RangeExpression() (localctx IRangeExpressionContext) { + this := p + _ = this + + localctx = NewRangeExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, KotlinParserRULE_rangeExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2230) + p.AdditiveExpression() + } + p.SetState(2241) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 333, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2231) + p.Match(KotlinParserRANGE) + } + p.SetState(2235) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2232) + p.Match(KotlinParserNL) + } + + p.SetState(2237) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2238) + p.AdditiveExpression() + } + + } + p.SetState(2243) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 333, p.GetParserRuleContext()) + } + + return localctx +} + +// IAdditiveExpressionContext is an interface to support dynamic dispatch. +type IAdditiveExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAdditiveExpressionContext differentiates from other interfaces. + IsAdditiveExpressionContext() +} + +type AdditiveExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdditiveExpressionContext() *AdditiveExpressionContext { + var p = new(AdditiveExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_additiveExpression + return p +} + +func (*AdditiveExpressionContext) IsAdditiveExpressionContext() {} + +func NewAdditiveExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveExpressionContext { + var p = new(AdditiveExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_additiveExpression + + return p +} + +func (s *AdditiveExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AdditiveExpressionContext) AllMultiplicativeExpression() []IMultiplicativeExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultiplicativeExpressionContext); ok { + len++ + } + } + + tst := make([]IMultiplicativeExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultiplicativeExpressionContext); ok { + tst[i] = t.(IMultiplicativeExpressionContext) + i++ + } + } + + return tst +} + +func (s *AdditiveExpressionContext) MultiplicativeExpression(i int) IMultiplicativeExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiplicativeExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultiplicativeExpressionContext) +} + +func (s *AdditiveExpressionContext) AllAdditiveOperator() []IAdditiveOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdditiveOperatorContext); ok { + len++ + } + } + + tst := make([]IAdditiveOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdditiveOperatorContext); ok { + tst[i] = t.(IAdditiveOperatorContext) + i++ + } + } + + return tst +} + +func (s *AdditiveExpressionContext) AdditiveOperator(i int) IAdditiveOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdditiveOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdditiveOperatorContext) +} + +func (s *AdditiveExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AdditiveExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AdditiveExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdditiveExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AdditiveExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAdditiveExpression(s) + } +} + +func (s *AdditiveExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAdditiveExpression(s) + } +} + +func (p *KotlinParser) AdditiveExpression() (localctx IAdditiveExpressionContext) { + this := p + _ = this + + localctx = NewAdditiveExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, KotlinParserRULE_additiveExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2244) + p.MultiplicativeExpression() + } + p.SetState(2256) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 335, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2245) + p.AdditiveOperator() + } + p.SetState(2249) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2246) + p.Match(KotlinParserNL) + } + + p.SetState(2251) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2252) + p.MultiplicativeExpression() + } + + } + p.SetState(2258) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 335, p.GetParserRuleContext()) + } + + return localctx +} + +// IMultiplicativeExpressionContext is an interface to support dynamic dispatch. +type IMultiplicativeExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiplicativeExpressionContext differentiates from other interfaces. + IsMultiplicativeExpressionContext() +} + +type MultiplicativeExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiplicativeExpressionContext() *MultiplicativeExpressionContext { + var p = new(MultiplicativeExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiplicativeExpression + return p +} + +func (*MultiplicativeExpressionContext) IsMultiplicativeExpressionContext() {} + +func NewMultiplicativeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeExpressionContext { + var p = new(MultiplicativeExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiplicativeExpression + + return p +} + +func (s *MultiplicativeExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiplicativeExpressionContext) AllAsExpression() []IAsExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAsExpressionContext); ok { + len++ + } + } + + tst := make([]IAsExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAsExpressionContext); ok { + tst[i] = t.(IAsExpressionContext) + i++ + } + } + + return tst +} + +func (s *MultiplicativeExpressionContext) AsExpression(i int) IAsExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAsExpressionContext) +} + +func (s *MultiplicativeExpressionContext) AllMultiplicativeOperator() []IMultiplicativeOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultiplicativeOperatorContext); ok { + len++ + } + } + + tst := make([]IMultiplicativeOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultiplicativeOperatorContext); ok { + tst[i] = t.(IMultiplicativeOperatorContext) + i++ + } + } + + return tst +} + +func (s *MultiplicativeExpressionContext) MultiplicativeOperator(i int) IMultiplicativeOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiplicativeOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultiplicativeOperatorContext) +} + +func (s *MultiplicativeExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *MultiplicativeExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *MultiplicativeExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiplicativeExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiplicativeExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiplicativeExpression(s) + } +} + +func (s *MultiplicativeExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiplicativeExpression(s) + } +} + +func (p *KotlinParser) MultiplicativeExpression() (localctx IMultiplicativeExpressionContext) { + this := p + _ = this + + localctx = NewMultiplicativeExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, KotlinParserRULE_multiplicativeExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2259) + p.AsExpression() + } + p.SetState(2271) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 337, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2260) + p.MultiplicativeOperator() + } + p.SetState(2264) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2261) + p.Match(KotlinParserNL) + } + + p.SetState(2266) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2267) + p.AsExpression() + } + + } + p.SetState(2273) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 337, p.GetParserRuleContext()) + } + + return localctx +} + +// IAsExpressionContext is an interface to support dynamic dispatch. +type IAsExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAsExpressionContext differentiates from other interfaces. + IsAsExpressionContext() +} + +type AsExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsExpressionContext() *AsExpressionContext { + var p = new(AsExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_asExpression + return p +} + +func (*AsExpressionContext) IsAsExpressionContext() {} + +func NewAsExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsExpressionContext { + var p = new(AsExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_asExpression + + return p +} + +func (s *AsExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AsExpressionContext) PrefixUnaryExpression() IPrefixUnaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrefixUnaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrefixUnaryExpressionContext) +} + +func (s *AsExpressionContext) AllAsOperator() []IAsOperatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAsOperatorContext); ok { + len++ + } + } + + tst := make([]IAsOperatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAsOperatorContext); ok { + tst[i] = t.(IAsOperatorContext) + i++ + } + } + + return tst +} + +func (s *AsExpressionContext) AsOperator(i int) IAsOperatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsOperatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAsOperatorContext) +} + +func (s *AsExpressionContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *AsExpressionContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *AsExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AsExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AsExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AsExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AsExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAsExpression(s) + } +} + +func (s *AsExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAsExpression(s) + } +} + +func (p *KotlinParser) AsExpression() (localctx IAsExpressionContext) { + this := p + _ = this + + localctx = NewAsExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, KotlinParserRULE_asExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2274) + p.PrefixUnaryExpression() + } + p.SetState(2292) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 340, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2278) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2275) + p.Match(KotlinParserNL) + } + + p.SetState(2280) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2281) + p.AsOperator() + } + p.SetState(2285) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2282) + p.Match(KotlinParserNL) + } + + p.SetState(2287) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2288) + p.Type_() + } + + } + p.SetState(2294) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 340, p.GetParserRuleContext()) + } + + return localctx +} + +// IPrefixUnaryExpressionContext is an interface to support dynamic dispatch. +type IPrefixUnaryExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPrefixUnaryExpressionContext differentiates from other interfaces. + IsPrefixUnaryExpressionContext() +} + +type PrefixUnaryExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrefixUnaryExpressionContext() *PrefixUnaryExpressionContext { + var p = new(PrefixUnaryExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_prefixUnaryExpression + return p +} + +func (*PrefixUnaryExpressionContext) IsPrefixUnaryExpressionContext() {} + +func NewPrefixUnaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrefixUnaryExpressionContext { + var p = new(PrefixUnaryExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_prefixUnaryExpression + + return p +} + +func (s *PrefixUnaryExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrefixUnaryExpressionContext) PostfixUnaryExpression() IPostfixUnaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPostfixUnaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPostfixUnaryExpressionContext) +} + +func (s *PrefixUnaryExpressionContext) AllUnaryPrefix() []IUnaryPrefixContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnaryPrefixContext); ok { + len++ + } + } + + tst := make([]IUnaryPrefixContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnaryPrefixContext); ok { + tst[i] = t.(IUnaryPrefixContext) + i++ + } + } + + return tst +} + +func (s *PrefixUnaryExpressionContext) UnaryPrefix(i int) IUnaryPrefixContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnaryPrefixContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnaryPrefixContext) +} + +func (s *PrefixUnaryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrefixUnaryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrefixUnaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPrefixUnaryExpression(s) + } +} + +func (s *PrefixUnaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPrefixUnaryExpression(s) + } +} + +func (p *KotlinParser) PrefixUnaryExpression() (localctx IPrefixUnaryExpressionContext) { + this := p + _ = this + + localctx = NewPrefixUnaryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, KotlinParserRULE_prefixUnaryExpression) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2298) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 341, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2295) + p.UnaryPrefix() + } + + } + p.SetState(2300) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 341, p.GetParserRuleContext()) + } + { + p.SetState(2301) + p.PostfixUnaryExpression() + } + + return localctx +} + +// IUnaryPrefixContext is an interface to support dynamic dispatch. +type IUnaryPrefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsUnaryPrefixContext differentiates from other interfaces. + IsUnaryPrefixContext() +} + +type UnaryPrefixContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnaryPrefixContext() *UnaryPrefixContext { + var p = new(UnaryPrefixContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_unaryPrefix + return p +} + +func (*UnaryPrefixContext) IsUnaryPrefixContext() {} + +func NewUnaryPrefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryPrefixContext { + var p = new(UnaryPrefixContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_unaryPrefix + + return p +} + +func (s *UnaryPrefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnaryPrefixContext) Annotation() IAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *UnaryPrefixContext) Label() ILabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabelContext) +} + +func (s *UnaryPrefixContext) PrefixUnaryOperator() IPrefixUnaryOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrefixUnaryOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrefixUnaryOperatorContext) +} + +func (s *UnaryPrefixContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *UnaryPrefixContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *UnaryPrefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnaryPrefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnaryPrefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterUnaryPrefix(s) + } +} + +func (s *UnaryPrefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitUnaryPrefix(s) + } +} + +func (p *KotlinParser) UnaryPrefix() (localctx IUnaryPrefixContext) { + this := p + _ = this + + localctx = NewUnaryPrefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, KotlinParserRULE_unaryPrefix) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2312) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2303) + p.Annotation() + } + + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2304) + p.Label() + } + + case KotlinParserADD, KotlinParserSUB, KotlinParserINCR, KotlinParserDECR, KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2305) + p.PrefixUnaryOperator() + } + p.SetState(2309) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2306) + p.Match(KotlinParserNL) + } + + p.SetState(2311) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IPostfixUnaryExpressionContext is an interface to support dynamic dispatch. +type IPostfixUnaryExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPostfixUnaryExpressionContext differentiates from other interfaces. + IsPostfixUnaryExpressionContext() +} + +type PostfixUnaryExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPostfixUnaryExpressionContext() *PostfixUnaryExpressionContext { + var p = new(PostfixUnaryExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_postfixUnaryExpression + return p +} + +func (*PostfixUnaryExpressionContext) IsPostfixUnaryExpressionContext() {} + +func NewPostfixUnaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostfixUnaryExpressionContext { + var p = new(PostfixUnaryExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_postfixUnaryExpression + + return p +} + +func (s *PostfixUnaryExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PostfixUnaryExpressionContext) PrimaryExpression() IPrimaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryExpressionContext) +} + +func (s *PostfixUnaryExpressionContext) AllPostfixUnarySuffix() []IPostfixUnarySuffixContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPostfixUnarySuffixContext); ok { + len++ + } + } + + tst := make([]IPostfixUnarySuffixContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPostfixUnarySuffixContext); ok { + tst[i] = t.(IPostfixUnarySuffixContext) + i++ + } + } + + return tst +} + +func (s *PostfixUnaryExpressionContext) PostfixUnarySuffix(i int) IPostfixUnarySuffixContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPostfixUnarySuffixContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPostfixUnarySuffixContext) +} + +func (s *PostfixUnaryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PostfixUnaryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PostfixUnaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPostfixUnaryExpression(s) + } +} + +func (s *PostfixUnaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPostfixUnaryExpression(s) + } +} + +func (p *KotlinParser) PostfixUnaryExpression() (localctx IPostfixUnaryExpressionContext) { + this := p + _ = this + + localctx = NewPostfixUnaryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, KotlinParserRULE_postfixUnaryExpression) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2314) + p.PrimaryExpression() + } + p.SetState(2318) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 344, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2315) + p.PostfixUnarySuffix() + } + + } + p.SetState(2320) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 344, p.GetParserRuleContext()) + } + + return localctx +} + +// IPostfixUnarySuffixContext is an interface to support dynamic dispatch. +type IPostfixUnarySuffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPostfixUnarySuffixContext differentiates from other interfaces. + IsPostfixUnarySuffixContext() +} + +type PostfixUnarySuffixContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPostfixUnarySuffixContext() *PostfixUnarySuffixContext { + var p = new(PostfixUnarySuffixContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_postfixUnarySuffix + return p +} + +func (*PostfixUnarySuffixContext) IsPostfixUnarySuffixContext() {} + +func NewPostfixUnarySuffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostfixUnarySuffixContext { + var p = new(PostfixUnarySuffixContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_postfixUnarySuffix + + return p +} + +func (s *PostfixUnarySuffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *PostfixUnarySuffixContext) PostfixUnaryOperator() IPostfixUnaryOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPostfixUnaryOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPostfixUnaryOperatorContext) +} + +func (s *PostfixUnarySuffixContext) TypeArguments() ITypeArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeArgumentsContext) +} + +func (s *PostfixUnarySuffixContext) CallSuffix() ICallSuffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallSuffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallSuffixContext) +} + +func (s *PostfixUnarySuffixContext) IndexingSuffix() IIndexingSuffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexingSuffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexingSuffixContext) +} + +func (s *PostfixUnarySuffixContext) NavigationSuffix() INavigationSuffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INavigationSuffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INavigationSuffixContext) +} + +func (s *PostfixUnarySuffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PostfixUnarySuffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PostfixUnarySuffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPostfixUnarySuffix(s) + } +} + +func (s *PostfixUnarySuffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPostfixUnarySuffix(s) + } +} + +func (p *KotlinParser) PostfixUnarySuffix() (localctx IPostfixUnarySuffixContext) { + this := p + _ = this + + localctx = NewPostfixUnarySuffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, KotlinParserRULE_postfixUnarySuffix) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2326) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 345, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2321) + p.PostfixUnaryOperator() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2322) + p.TypeArguments() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2323) + p.CallSuffix() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2324) + p.IndexingSuffix() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2325) + p.NavigationSuffix() + } + + } + + return localctx +} + +// IDirectlyAssignableExpressionContext is an interface to support dynamic dispatch. +type IDirectlyAssignableExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsDirectlyAssignableExpressionContext differentiates from other interfaces. + IsDirectlyAssignableExpressionContext() +} + +type DirectlyAssignableExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectlyAssignableExpressionContext() *DirectlyAssignableExpressionContext { + var p = new(DirectlyAssignableExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_directlyAssignableExpression + return p +} + +func (*DirectlyAssignableExpressionContext) IsDirectlyAssignableExpressionContext() {} + +func NewDirectlyAssignableExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DirectlyAssignableExpressionContext { + var p = new(DirectlyAssignableExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_directlyAssignableExpression + + return p +} + +func (s *DirectlyAssignableExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DirectlyAssignableExpressionContext) PostfixUnaryExpression() IPostfixUnaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPostfixUnaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPostfixUnaryExpressionContext) +} + +func (s *DirectlyAssignableExpressionContext) AssignableSuffix() IAssignableSuffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignableSuffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignableSuffixContext) +} + +func (s *DirectlyAssignableExpressionContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *DirectlyAssignableExpressionContext) ParenthesizedDirectlyAssignableExpression() IParenthesizedDirectlyAssignableExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedDirectlyAssignableExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedDirectlyAssignableExpressionContext) +} + +func (s *DirectlyAssignableExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DirectlyAssignableExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DirectlyAssignableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterDirectlyAssignableExpression(s) + } +} + +func (s *DirectlyAssignableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitDirectlyAssignableExpression(s) + } +} + +func (p *KotlinParser) DirectlyAssignableExpression() (localctx IDirectlyAssignableExpressionContext) { + this := p + _ = this + + localctx = NewDirectlyAssignableExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, KotlinParserRULE_directlyAssignableExpression) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2333) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 346, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2328) + p.PostfixUnaryExpression() + } + { + p.SetState(2329) + p.AssignableSuffix() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2331) + p.SimpleIdentifier() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2332) + p.ParenthesizedDirectlyAssignableExpression() + } + + } + + return localctx +} + +// IParenthesizedDirectlyAssignableExpressionContext is an interface to support dynamic dispatch. +type IParenthesizedDirectlyAssignableExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParenthesizedDirectlyAssignableExpressionContext differentiates from other interfaces. + IsParenthesizedDirectlyAssignableExpressionContext() +} + +type ParenthesizedDirectlyAssignableExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesizedDirectlyAssignableExpressionContext() *ParenthesizedDirectlyAssignableExpressionContext { + var p = new(ParenthesizedDirectlyAssignableExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parenthesizedDirectlyAssignableExpression + return p +} + +func (*ParenthesizedDirectlyAssignableExpressionContext) IsParenthesizedDirectlyAssignableExpressionContext() { +} + +func NewParenthesizedDirectlyAssignableExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenthesizedDirectlyAssignableExpressionContext { + var p = new(ParenthesizedDirectlyAssignableExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parenthesizedDirectlyAssignableExpression + + return p +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParenthesizedDirectlyAssignableExpressionContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) DirectlyAssignableExpression() IDirectlyAssignableExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectlyAssignableExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectlyAssignableExpressionContext) +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParenthesizedDirectlyAssignableExpression(s) + } +} + +func (s *ParenthesizedDirectlyAssignableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParenthesizedDirectlyAssignableExpression(s) + } +} + +func (p *KotlinParser) ParenthesizedDirectlyAssignableExpression() (localctx IParenthesizedDirectlyAssignableExpressionContext) { + this := p + _ = this + + localctx = NewParenthesizedDirectlyAssignableExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, KotlinParserRULE_parenthesizedDirectlyAssignableExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2335) + p.Match(KotlinParserLPAREN) + } + p.SetState(2339) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2336) + p.Match(KotlinParserNL) + } + + p.SetState(2341) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2342) + p.DirectlyAssignableExpression() + } + p.SetState(2346) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2343) + p.Match(KotlinParserNL) + } + + p.SetState(2348) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2349) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IAssignableExpressionContext is an interface to support dynamic dispatch. +type IAssignableExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAssignableExpressionContext differentiates from other interfaces. + IsAssignableExpressionContext() +} + +type AssignableExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignableExpressionContext() *AssignableExpressionContext { + var p = new(AssignableExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_assignableExpression + return p +} + +func (*AssignableExpressionContext) IsAssignableExpressionContext() {} + +func NewAssignableExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignableExpressionContext { + var p = new(AssignableExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_assignableExpression + + return p +} + +func (s *AssignableExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignableExpressionContext) PrefixUnaryExpression() IPrefixUnaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrefixUnaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrefixUnaryExpressionContext) +} + +func (s *AssignableExpressionContext) ParenthesizedAssignableExpression() IParenthesizedAssignableExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedAssignableExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedAssignableExpressionContext) +} + +func (s *AssignableExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignableExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAssignableExpression(s) + } +} + +func (s *AssignableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAssignableExpression(s) + } +} + +func (p *KotlinParser) AssignableExpression() (localctx IAssignableExpressionContext) { + this := p + _ = this + + localctx = NewAssignableExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, KotlinParserRULE_assignableExpression) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2353) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 349, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2351) + p.PrefixUnaryExpression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2352) + p.ParenthesizedAssignableExpression() + } + + } + + return localctx +} + +// IParenthesizedAssignableExpressionContext is an interface to support dynamic dispatch. +type IParenthesizedAssignableExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParenthesizedAssignableExpressionContext differentiates from other interfaces. + IsParenthesizedAssignableExpressionContext() +} + +type ParenthesizedAssignableExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesizedAssignableExpressionContext() *ParenthesizedAssignableExpressionContext { + var p = new(ParenthesizedAssignableExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parenthesizedAssignableExpression + return p +} + +func (*ParenthesizedAssignableExpressionContext) IsParenthesizedAssignableExpressionContext() {} + +func NewParenthesizedAssignableExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenthesizedAssignableExpressionContext { + var p = new(ParenthesizedAssignableExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parenthesizedAssignableExpression + + return p +} + +func (s *ParenthesizedAssignableExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParenthesizedAssignableExpressionContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ParenthesizedAssignableExpressionContext) AssignableExpression() IAssignableExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignableExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignableExpressionContext) +} + +func (s *ParenthesizedAssignableExpressionContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ParenthesizedAssignableExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParenthesizedAssignableExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParenthesizedAssignableExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesizedAssignableExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParenthesizedAssignableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParenthesizedAssignableExpression(s) + } +} + +func (s *ParenthesizedAssignableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParenthesizedAssignableExpression(s) + } +} + +func (p *KotlinParser) ParenthesizedAssignableExpression() (localctx IParenthesizedAssignableExpressionContext) { + this := p + _ = this + + localctx = NewParenthesizedAssignableExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, KotlinParserRULE_parenthesizedAssignableExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2355) + p.Match(KotlinParserLPAREN) + } + p.SetState(2359) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2356) + p.Match(KotlinParserNL) + } + + p.SetState(2361) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2362) + p.AssignableExpression() + } + p.SetState(2366) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2363) + p.Match(KotlinParserNL) + } + + p.SetState(2368) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2369) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IAssignableSuffixContext is an interface to support dynamic dispatch. +type IAssignableSuffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAssignableSuffixContext differentiates from other interfaces. + IsAssignableSuffixContext() +} + +type AssignableSuffixContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignableSuffixContext() *AssignableSuffixContext { + var p = new(AssignableSuffixContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_assignableSuffix + return p +} + +func (*AssignableSuffixContext) IsAssignableSuffixContext() {} + +func NewAssignableSuffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignableSuffixContext { + var p = new(AssignableSuffixContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_assignableSuffix + + return p +} + +func (s *AssignableSuffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignableSuffixContext) TypeArguments() ITypeArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeArgumentsContext) +} + +func (s *AssignableSuffixContext) IndexingSuffix() IIndexingSuffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexingSuffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexingSuffixContext) +} + +func (s *AssignableSuffixContext) NavigationSuffix() INavigationSuffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INavigationSuffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INavigationSuffixContext) +} + +func (s *AssignableSuffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignableSuffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignableSuffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAssignableSuffix(s) + } +} + +func (s *AssignableSuffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAssignableSuffix(s) + } +} + +func (p *KotlinParser) AssignableSuffix() (localctx IAssignableSuffixContext) { + this := p + _ = this + + localctx = NewAssignableSuffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, KotlinParserRULE_assignableSuffix) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2374) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLANGLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2371) + p.TypeArguments() + } + + case KotlinParserLSQUARE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2372) + p.IndexingSuffix() + } + + case KotlinParserNL, KotlinParserDOT, KotlinParserCOLONCOLON, KotlinParserQUEST_NO_WS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2373) + p.NavigationSuffix() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IIndexingSuffixContext is an interface to support dynamic dispatch. +type IIndexingSuffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsIndexingSuffixContext differentiates from other interfaces. + IsIndexingSuffixContext() +} + +type IndexingSuffixContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexingSuffixContext() *IndexingSuffixContext { + var p = new(IndexingSuffixContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_indexingSuffix + return p +} + +func (*IndexingSuffixContext) IsIndexingSuffixContext() {} + +func NewIndexingSuffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexingSuffixContext { + var p = new(IndexingSuffixContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_indexingSuffix + + return p +} + +func (s *IndexingSuffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexingSuffixContext) LSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserLSQUARE, 0) +} + +func (s *IndexingSuffixContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *IndexingSuffixContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IndexingSuffixContext) RSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserRSQUARE, 0) +} + +func (s *IndexingSuffixContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *IndexingSuffixContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *IndexingSuffixContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *IndexingSuffixContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *IndexingSuffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexingSuffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexingSuffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterIndexingSuffix(s) + } +} + +func (s *IndexingSuffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitIndexingSuffix(s) + } +} + +func (p *KotlinParser) IndexingSuffix() (localctx IIndexingSuffixContext) { + this := p + _ = this + + localctx = NewIndexingSuffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, KotlinParserRULE_indexingSuffix) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2376) + p.Match(KotlinParserLSQUARE) + } + p.SetState(2380) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2377) + p.Match(KotlinParserNL) + } + + p.SetState(2382) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2383) + p.Expression() + } + p.SetState(2400) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 356, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2387) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2384) + p.Match(KotlinParserNL) + } + + p.SetState(2389) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2390) + p.Match(KotlinParserCOMMA) + } + p.SetState(2394) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2391) + p.Match(KotlinParserNL) + } + + p.SetState(2396) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2397) + p.Expression() + } + + } + p.SetState(2402) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 356, p.GetParserRuleContext()) + } + p.SetState(2410) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 358, p.GetParserRuleContext()) == 1 { + p.SetState(2406) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2403) + p.Match(KotlinParserNL) + } + + p.SetState(2408) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2409) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(2415) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2412) + p.Match(KotlinParserNL) + } + + p.SetState(2417) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2418) + p.Match(KotlinParserRSQUARE) + } + + return localctx +} + +// INavigationSuffixContext is an interface to support dynamic dispatch. +type INavigationSuffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsNavigationSuffixContext differentiates from other interfaces. + IsNavigationSuffixContext() +} + +type NavigationSuffixContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNavigationSuffixContext() *NavigationSuffixContext { + var p = new(NavigationSuffixContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_navigationSuffix + return p +} + +func (*NavigationSuffixContext) IsNavigationSuffixContext() {} + +func NewNavigationSuffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NavigationSuffixContext { + var p = new(NavigationSuffixContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_navigationSuffix + + return p +} + +func (s *NavigationSuffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *NavigationSuffixContext) MemberAccessOperator() IMemberAccessOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMemberAccessOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMemberAccessOperatorContext) +} + +func (s *NavigationSuffixContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *NavigationSuffixContext) ParenthesizedExpression() IParenthesizedExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedExpressionContext) +} + +func (s *NavigationSuffixContext) CLASS() antlr.TerminalNode { + return s.GetToken(KotlinParserCLASS, 0) +} + +func (s *NavigationSuffixContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *NavigationSuffixContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *NavigationSuffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NavigationSuffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NavigationSuffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterNavigationSuffix(s) + } +} + +func (s *NavigationSuffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitNavigationSuffix(s) + } +} + +func (p *KotlinParser) NavigationSuffix() (localctx INavigationSuffixContext) { + this := p + _ = this + + localctx = NewNavigationSuffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, KotlinParserRULE_navigationSuffix) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2420) + p.MemberAccessOperator() + } + p.SetState(2424) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2421) + p.Match(KotlinParserNL) + } + + p.SetState(2426) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(2430) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(2427) + p.SimpleIdentifier() + } + + case KotlinParserLPAREN: + { + p.SetState(2428) + p.ParenthesizedExpression() + } + + case KotlinParserCLASS: + { + p.SetState(2429) + p.Match(KotlinParserCLASS) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// ICallSuffixContext is an interface to support dynamic dispatch. +type ICallSuffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsCallSuffixContext differentiates from other interfaces. + IsCallSuffixContext() +} + +type CallSuffixContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCallSuffixContext() *CallSuffixContext { + var p = new(CallSuffixContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_callSuffix + return p +} + +func (*CallSuffixContext) IsCallSuffixContext() {} + +func NewCallSuffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallSuffixContext { + var p = new(CallSuffixContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_callSuffix + + return p +} + +func (s *CallSuffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *CallSuffixContext) AnnotatedLambda() IAnnotatedLambdaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotatedLambdaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotatedLambdaContext) +} + +func (s *CallSuffixContext) ValueArguments() IValueArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueArgumentsContext) +} + +func (s *CallSuffixContext) TypeArguments() ITypeArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeArgumentsContext) +} + +func (s *CallSuffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CallSuffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CallSuffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterCallSuffix(s) + } +} + +func (s *CallSuffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitCallSuffix(s) + } +} + +func (p *KotlinParser) CallSuffix() (localctx ICallSuffixContext) { + this := p + _ = this + + localctx = NewCallSuffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, KotlinParserRULE_callSuffix) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(2433) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserLANGLE { + { + p.SetState(2432) + p.TypeArguments() + } + + } + p.SetState(2440) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 364, p.GetParserRuleContext()) { + case 1: + p.SetState(2436) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserLPAREN { + { + p.SetState(2435) + p.ValueArguments() + } + + } + { + p.SetState(2438) + p.AnnotatedLambda() + } + + case 2: + { + p.SetState(2439) + p.ValueArguments() + } + + } + + return localctx +} + +// IAnnotatedLambdaContext is an interface to support dynamic dispatch. +type IAnnotatedLambdaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAnnotatedLambdaContext differentiates from other interfaces. + IsAnnotatedLambdaContext() +} + +type AnnotatedLambdaContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotatedLambdaContext() *AnnotatedLambdaContext { + var p = new(AnnotatedLambdaContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_annotatedLambda + return p +} + +func (*AnnotatedLambdaContext) IsAnnotatedLambdaContext() {} + +func NewAnnotatedLambdaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotatedLambdaContext { + var p = new(AnnotatedLambdaContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_annotatedLambda + + return p +} + +func (s *AnnotatedLambdaContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnnotatedLambdaContext) LambdaLiteral() ILambdaLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambdaLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambdaLiteralContext) +} + +func (s *AnnotatedLambdaContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *AnnotatedLambdaContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *AnnotatedLambdaContext) Label() ILabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabelContext) +} + +func (s *AnnotatedLambdaContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AnnotatedLambdaContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AnnotatedLambdaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnnotatedLambdaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnnotatedLambdaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAnnotatedLambda(s) + } +} + +func (s *AnnotatedLambdaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAnnotatedLambda(s) + } +} + +func (p *KotlinParser) AnnotatedLambda() (localctx IAnnotatedLambdaContext) { + this := p + _ = this + + localctx = NewAnnotatedLambdaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, KotlinParserRULE_annotatedLambda) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(2445) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS { + { + p.SetState(2442) + p.Annotation() + } + + p.SetState(2447) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(2449) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&-17588927330817) != 0 || (int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&2098175) != 0 { + { + p.SetState(2448) + p.Label() + } + + } + p.SetState(2454) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2451) + p.Match(KotlinParserNL) + } + + p.SetState(2456) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2457) + p.LambdaLiteral() + } + + return localctx +} + +// ITypeArgumentsContext is an interface to support dynamic dispatch. +type ITypeArgumentsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeArgumentsContext differentiates from other interfaces. + IsTypeArgumentsContext() +} + +type TypeArgumentsContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeArgumentsContext() *TypeArgumentsContext { + var p = new(TypeArgumentsContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeArguments + return p +} + +func (*TypeArgumentsContext) IsTypeArgumentsContext() {} + +func NewTypeArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeArgumentsContext { + var p = new(TypeArgumentsContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeArguments + + return p +} + +func (s *TypeArgumentsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeArgumentsContext) LANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserLANGLE, 0) +} + +func (s *TypeArgumentsContext) AllTypeProjection() []ITypeProjectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeProjectionContext); ok { + len++ + } + } + + tst := make([]ITypeProjectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeProjectionContext); ok { + tst[i] = t.(ITypeProjectionContext) + i++ + } + } + + return tst +} + +func (s *TypeArgumentsContext) TypeProjection(i int) ITypeProjectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeProjectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeProjectionContext) +} + +func (s *TypeArgumentsContext) RANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserRANGLE, 0) +} + +func (s *TypeArgumentsContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeArgumentsContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeArgumentsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *TypeArgumentsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *TypeArgumentsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeArgumentsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeArguments(s) + } +} + +func (s *TypeArgumentsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeArguments(s) + } +} + +func (p *KotlinParser) TypeArguments() (localctx ITypeArgumentsContext) { + this := p + _ = this + + localctx = NewTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, KotlinParserRULE_typeArguments) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2459) + p.Match(KotlinParserLANGLE) + } + p.SetState(2463) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2460) + p.Match(KotlinParserNL) + } + + p.SetState(2465) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2466) + p.TypeProjection() + } + p.SetState(2483) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 371, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2470) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2467) + p.Match(KotlinParserNL) + } + + p.SetState(2472) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2473) + p.Match(KotlinParserCOMMA) + } + p.SetState(2477) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2474) + p.Match(KotlinParserNL) + } + + p.SetState(2479) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2480) + p.TypeProjection() + } + + } + p.SetState(2485) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 371, p.GetParserRuleContext()) + } + p.SetState(2493) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 373, p.GetParserRuleContext()) == 1 { + p.SetState(2489) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2486) + p.Match(KotlinParserNL) + } + + p.SetState(2491) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2492) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(2498) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2495) + p.Match(KotlinParserNL) + } + + p.SetState(2500) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2501) + p.Match(KotlinParserRANGLE) + } + + return localctx +} + +// IValueArgumentsContext is an interface to support dynamic dispatch. +type IValueArgumentsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsValueArgumentsContext differentiates from other interfaces. + IsValueArgumentsContext() +} + +type ValueArgumentsContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValueArgumentsContext() *ValueArgumentsContext { + var p = new(ValueArgumentsContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_valueArguments + return p +} + +func (*ValueArgumentsContext) IsValueArgumentsContext() {} + +func NewValueArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueArgumentsContext { + var p = new(ValueArgumentsContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_valueArguments + + return p +} + +func (s *ValueArgumentsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ValueArgumentsContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ValueArgumentsContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ValueArgumentsContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ValueArgumentsContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ValueArgumentsContext) AllValueArgument() []IValueArgumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValueArgumentContext); ok { + len++ + } + } + + tst := make([]IValueArgumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValueArgumentContext); ok { + tst[i] = t.(IValueArgumentContext) + i++ + } + } + + return tst +} + +func (s *ValueArgumentsContext) ValueArgument(i int) IValueArgumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueArgumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValueArgumentContext) +} + +func (s *ValueArgumentsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *ValueArgumentsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *ValueArgumentsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValueArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ValueArgumentsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterValueArguments(s) + } +} + +func (s *ValueArgumentsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitValueArguments(s) + } +} + +func (p *KotlinParser) ValueArguments() (localctx IValueArgumentsContext) { + this := p + _ = this + + localctx = NewValueArgumentsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, KotlinParserRULE_valueArguments) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2503) + p.Match(KotlinParserLPAREN) + } + p.SetState(2507) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 375, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2504) + p.Match(KotlinParserNL) + } + + } + p.SetState(2509) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 375, p.GetParserRuleContext()) + } + p.SetState(2545) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-144109553024456160) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-4268161558145) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&13629951) != 0 { + { + p.SetState(2510) + p.ValueArgument() + } + p.SetState(2527) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 378, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2514) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2511) + p.Match(KotlinParserNL) + } + + p.SetState(2516) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2517) + p.Match(KotlinParserCOMMA) + } + p.SetState(2521) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 377, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2518) + p.Match(KotlinParserNL) + } + + } + p.SetState(2523) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 377, p.GetParserRuleContext()) + } + { + p.SetState(2524) + p.ValueArgument() + } + + } + p.SetState(2529) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 378, p.GetParserRuleContext()) + } + p.SetState(2537) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 380, p.GetParserRuleContext()) == 1 { + p.SetState(2533) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2530) + p.Match(KotlinParserNL) + } + + p.SetState(2535) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2536) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(2542) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2539) + p.Match(KotlinParserNL) + } + + p.SetState(2544) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(2547) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IValueArgumentContext is an interface to support dynamic dispatch. +type IValueArgumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsValueArgumentContext differentiates from other interfaces. + IsValueArgumentContext() +} + +type ValueArgumentContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValueArgumentContext() *ValueArgumentContext { + var p = new(ValueArgumentContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_valueArgument + return p +} + +func (*ValueArgumentContext) IsValueArgumentContext() {} + +func NewValueArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueArgumentContext { + var p = new(ValueArgumentContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_valueArgument + + return p +} + +func (s *ValueArgumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *ValueArgumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ValueArgumentContext) Annotation() IAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *ValueArgumentContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ValueArgumentContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ValueArgumentContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *ValueArgumentContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *ValueArgumentContext) MULT() antlr.TerminalNode { + return s.GetToken(KotlinParserMULT, 0) +} + +func (s *ValueArgumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValueArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ValueArgumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterValueArgument(s) + } +} + +func (s *ValueArgumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitValueArgument(s) + } +} + +func (p *KotlinParser) ValueArgument() (localctx IValueArgumentContext) { + this := p + _ = this + + localctx = NewValueArgumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, KotlinParserRULE_valueArgument) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2550) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 383, p.GetParserRuleContext()) == 1 { + { + p.SetState(2549) + p.Annotation() + } + + } + p.SetState(2555) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 384, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2552) + p.Match(KotlinParserNL) + } + + } + p.SetState(2557) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 384, p.GetParserRuleContext()) + } + p.SetState(2572) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 387, p.GetParserRuleContext()) == 1 { + { + p.SetState(2558) + p.SimpleIdentifier() + } + p.SetState(2562) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2559) + p.Match(KotlinParserNL) + } + + p.SetState(2564) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2565) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(2569) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 386, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2566) + p.Match(KotlinParserNL) + } + + } + p.SetState(2571) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 386, p.GetParserRuleContext()) + } + + } + p.SetState(2575) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserMULT { + { + p.SetState(2574) + p.Match(KotlinParserMULT) + } + + } + p.SetState(2580) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2577) + p.Match(KotlinParserNL) + } + + p.SetState(2582) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2583) + p.Expression() + } + + return localctx +} + +// IPrimaryExpressionContext is an interface to support dynamic dispatch. +type IPrimaryExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPrimaryExpressionContext differentiates from other interfaces. + IsPrimaryExpressionContext() +} + +type PrimaryExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext { + var p = new(PrimaryExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_primaryExpression + return p +} + +func (*PrimaryExpressionContext) IsPrimaryExpressionContext() {} + +func NewPrimaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExpressionContext { + var p = new(PrimaryExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_primaryExpression + + return p +} + +func (s *PrimaryExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimaryExpressionContext) ParenthesizedExpression() IParenthesizedExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesizedExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesizedExpressionContext) +} + +func (s *PrimaryExpressionContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *PrimaryExpressionContext) LiteralConstant() ILiteralConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILiteralConstantContext) +} + +func (s *PrimaryExpressionContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *PrimaryExpressionContext) CallableReference() ICallableReferenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallableReferenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallableReferenceContext) +} + +func (s *PrimaryExpressionContext) FunctionLiteral() IFunctionLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionLiteralContext) +} + +func (s *PrimaryExpressionContext) ObjectLiteral() IObjectLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObjectLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObjectLiteralContext) +} + +func (s *PrimaryExpressionContext) CollectionLiteral() ICollectionLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollectionLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollectionLiteralContext) +} + +func (s *PrimaryExpressionContext) ThisExpression() IThisExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThisExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IThisExpressionContext) +} + +func (s *PrimaryExpressionContext) SuperExpression() ISuperExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISuperExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISuperExpressionContext) +} + +func (s *PrimaryExpressionContext) IfExpression() IIfExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExpressionContext) +} + +func (s *PrimaryExpressionContext) WhenExpression() IWhenExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhenExpressionContext) +} + +func (s *PrimaryExpressionContext) TryExpression() ITryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITryExpressionContext) +} + +func (s *PrimaryExpressionContext) JumpExpression() IJumpExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJumpExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJumpExpressionContext) +} + +func (s *PrimaryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrimaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPrimaryExpression(s) + } +} + +func (s *PrimaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPrimaryExpression(s) + } +} + +func (p *KotlinParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { + this := p + _ = this + + localctx = NewPrimaryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, KotlinParserRULE_primaryExpression) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2599) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 390, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2585) + p.ParenthesizedExpression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2586) + p.SimpleIdentifier() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2587) + p.LiteralConstant() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2588) + p.StringLiteral() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2589) + p.CallableReference() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2590) + p.FunctionLiteral() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2591) + p.ObjectLiteral() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2592) + p.CollectionLiteral() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2593) + p.ThisExpression() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2594) + p.SuperExpression() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2595) + p.IfExpression() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2596) + p.WhenExpression() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2597) + p.TryExpression() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2598) + p.JumpExpression() + } + + } + + return localctx +} + +// IParenthesizedExpressionContext is an interface to support dynamic dispatch. +type IParenthesizedExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParenthesizedExpressionContext differentiates from other interfaces. + IsParenthesizedExpressionContext() +} + +type ParenthesizedExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesizedExpressionContext() *ParenthesizedExpressionContext { + var p = new(ParenthesizedExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parenthesizedExpression + return p +} + +func (*ParenthesizedExpressionContext) IsParenthesizedExpressionContext() {} + +func NewParenthesizedExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParenthesizedExpressionContext { + var p = new(ParenthesizedExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parenthesizedExpression + + return p +} + +func (s *ParenthesizedExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParenthesizedExpressionContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *ParenthesizedExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ParenthesizedExpressionContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *ParenthesizedExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ParenthesizedExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ParenthesizedExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesizedExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParenthesizedExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParenthesizedExpression(s) + } +} + +func (s *ParenthesizedExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParenthesizedExpression(s) + } +} + +func (p *KotlinParser) ParenthesizedExpression() (localctx IParenthesizedExpressionContext) { + this := p + _ = this + + localctx = NewParenthesizedExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, KotlinParserRULE_parenthesizedExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2601) + p.Match(KotlinParserLPAREN) + } + p.SetState(2605) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2602) + p.Match(KotlinParserNL) + } + + p.SetState(2607) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2608) + p.Expression() + } + p.SetState(2612) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2609) + p.Match(KotlinParserNL) + } + + p.SetState(2614) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2615) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// ICollectionLiteralContext is an interface to support dynamic dispatch. +type ICollectionLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsCollectionLiteralContext differentiates from other interfaces. + IsCollectionLiteralContext() +} + +type CollectionLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollectionLiteralContext() *CollectionLiteralContext { + var p = new(CollectionLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_collectionLiteral + return p +} + +func (*CollectionLiteralContext) IsCollectionLiteralContext() {} + +func NewCollectionLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionLiteralContext { + var p = new(CollectionLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_collectionLiteral + + return p +} + +func (s *CollectionLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *CollectionLiteralContext) LSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserLSQUARE, 0) +} + +func (s *CollectionLiteralContext) RSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserRSQUARE, 0) +} + +func (s *CollectionLiteralContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *CollectionLiteralContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *CollectionLiteralContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CollectionLiteralContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CollectionLiteralContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *CollectionLiteralContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *CollectionLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollectionLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CollectionLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterCollectionLiteral(s) + } +} + +func (s *CollectionLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitCollectionLiteral(s) + } +} + +func (p *KotlinParser) CollectionLiteral() (localctx ICollectionLiteralContext) { + this := p + _ = this + + localctx = NewCollectionLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, KotlinParserRULE_collectionLiteral) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2617) + p.Match(KotlinParserLSQUARE) + } + p.SetState(2621) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2618) + p.Match(KotlinParserNL) + } + + p.SetState(2623) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(2659) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-144109553024488960) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-4268161558145) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&13629951) != 0 { + { + p.SetState(2624) + p.Expression() + } + p.SetState(2641) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 396, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2628) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2625) + p.Match(KotlinParserNL) + } + + p.SetState(2630) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2631) + p.Match(KotlinParserCOMMA) + } + p.SetState(2635) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2632) + p.Match(KotlinParserNL) + } + + p.SetState(2637) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2638) + p.Expression() + } + + } + p.SetState(2643) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 396, p.GetParserRuleContext()) + } + p.SetState(2651) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 398, p.GetParserRuleContext()) == 1 { + p.SetState(2647) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2644) + p.Match(KotlinParserNL) + } + + p.SetState(2649) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2650) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(2656) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2653) + p.Match(KotlinParserNL) + } + + p.SetState(2658) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(2661) + p.Match(KotlinParserRSQUARE) + } + + return localctx +} + +// ILiteralConstantContext is an interface to support dynamic dispatch. +type ILiteralConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLiteralConstantContext differentiates from other interfaces. + IsLiteralConstantContext() +} + +type LiteralConstantContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLiteralConstantContext() *LiteralConstantContext { + var p = new(LiteralConstantContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_literalConstant + return p +} + +func (*LiteralConstantContext) IsLiteralConstantContext() {} + +func NewLiteralConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralConstantContext { + var p = new(LiteralConstantContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_literalConstant + + return p +} + +func (s *LiteralConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *LiteralConstantContext) BooleanLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserBooleanLiteral, 0) +} + +func (s *LiteralConstantContext) IntegerLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserIntegerLiteral, 0) +} + +func (s *LiteralConstantContext) HexLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserHexLiteral, 0) +} + +func (s *LiteralConstantContext) BinLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserBinLiteral, 0) +} + +func (s *LiteralConstantContext) CharacterLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserCharacterLiteral, 0) +} + +func (s *LiteralConstantContext) RealLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserRealLiteral, 0) +} + +func (s *LiteralConstantContext) NullLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserNullLiteral, 0) +} + +func (s *LiteralConstantContext) LongLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserLongLiteral, 0) +} + +func (s *LiteralConstantContext) UnsignedLiteral() antlr.TerminalNode { + return s.GetToken(KotlinParserUnsignedLiteral, 0) +} + +func (s *LiteralConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LiteralConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LiteralConstantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLiteralConstant(s) + } +} + +func (s *LiteralConstantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLiteralConstant(s) + } +} + +func (p *KotlinParser) LiteralConstant() (localctx ILiteralConstantContext) { + this := p + _ = this + + localctx = NewLiteralConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, KotlinParserRULE_literalConstant) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2663) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-136)) & ^0x3f) == 0 && ((int64(1)<<(_la-136))&2041) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IStringLiteralContext is an interface to support dynamic dispatch. +type IStringLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsStringLiteralContext differentiates from other interfaces. + IsStringLiteralContext() +} + +type StringLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStringLiteralContext() *StringLiteralContext { + var p = new(StringLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_stringLiteral + return p +} + +func (*StringLiteralContext) IsStringLiteralContext() {} + +func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext { + var p = new(StringLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_stringLiteral + + return p +} + +func (s *StringLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *StringLiteralContext) LineStringLiteral() ILineStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILineStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILineStringLiteralContext) +} + +func (s *StringLiteralContext) MultiLineStringLiteral() IMultiLineStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiLineStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiLineStringLiteralContext) +} + +func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterStringLiteral(s) + } +} + +func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitStringLiteral(s) + } +} + +func (p *KotlinParser) StringLiteral() (localctx IStringLiteralContext) { + this := p + _ = this + + localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, KotlinParserRULE_stringLiteral) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2667) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserQUOTE_OPEN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2665) + p.LineStringLiteral() + } + + case KotlinParserTRIPLE_QUOTE_OPEN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2666) + p.MultiLineStringLiteral() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// ILineStringLiteralContext is an interface to support dynamic dispatch. +type ILineStringLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLineStringLiteralContext differentiates from other interfaces. + IsLineStringLiteralContext() +} + +type LineStringLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLineStringLiteralContext() *LineStringLiteralContext { + var p = new(LineStringLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_lineStringLiteral + return p +} + +func (*LineStringLiteralContext) IsLineStringLiteralContext() {} + +func NewLineStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LineStringLiteralContext { + var p = new(LineStringLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_lineStringLiteral + + return p +} + +func (s *LineStringLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *LineStringLiteralContext) QUOTE_OPEN() antlr.TerminalNode { + return s.GetToken(KotlinParserQUOTE_OPEN, 0) +} + +func (s *LineStringLiteralContext) QUOTE_CLOSE() antlr.TerminalNode { + return s.GetToken(KotlinParserQUOTE_CLOSE, 0) +} + +func (s *LineStringLiteralContext) AllLineStringContent() []ILineStringContentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILineStringContentContext); ok { + len++ + } + } + + tst := make([]ILineStringContentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILineStringContentContext); ok { + tst[i] = t.(ILineStringContentContext) + i++ + } + } + + return tst +} + +func (s *LineStringLiteralContext) LineStringContent(i int) ILineStringContentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILineStringContentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILineStringContentContext) +} + +func (s *LineStringLiteralContext) AllLineStringExpression() []ILineStringExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILineStringExpressionContext); ok { + len++ + } + } + + tst := make([]ILineStringExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILineStringExpressionContext); ok { + tst[i] = t.(ILineStringExpressionContext) + i++ + } + } + + return tst +} + +func (s *LineStringLiteralContext) LineStringExpression(i int) ILineStringExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILineStringExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILineStringExpressionContext) +} + +func (s *LineStringLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LineStringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LineStringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLineStringLiteral(s) + } +} + +func (s *LineStringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLineStringLiteral(s) + } +} + +func (p *KotlinParser) LineStringLiteral() (localctx ILineStringLiteralContext) { + this := p + _ = this + + localctx = NewLineStringLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, KotlinParserRULE_lineStringLiteral) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2669) + p.Match(KotlinParserQUOTE_OPEN) + } + p.SetState(2674) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for (int64((_la-160)) & ^0x3f) == 0 && ((int64(1)<<(_la-160))&15) != 0 { + p.SetState(2672) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLineStrRef, KotlinParserLineStrText, KotlinParserLineStrEscapedChar: + { + p.SetState(2670) + p.LineStringContent() + } + + case KotlinParserLineStrExprStart: + { + p.SetState(2671) + p.LineStringExpression() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(2676) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2677) + p.Match(KotlinParserQUOTE_CLOSE) + } + + return localctx +} + +// IMultiLineStringLiteralContext is an interface to support dynamic dispatch. +type IMultiLineStringLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiLineStringLiteralContext differentiates from other interfaces. + IsMultiLineStringLiteralContext() +} + +type MultiLineStringLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiLineStringLiteralContext() *MultiLineStringLiteralContext { + var p = new(MultiLineStringLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiLineStringLiteral + return p +} + +func (*MultiLineStringLiteralContext) IsMultiLineStringLiteralContext() {} + +func NewMultiLineStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiLineStringLiteralContext { + var p = new(MultiLineStringLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiLineStringLiteral + + return p +} + +func (s *MultiLineStringLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiLineStringLiteralContext) TRIPLE_QUOTE_OPEN() antlr.TerminalNode { + return s.GetToken(KotlinParserTRIPLE_QUOTE_OPEN, 0) +} + +func (s *MultiLineStringLiteralContext) TRIPLE_QUOTE_CLOSE() antlr.TerminalNode { + return s.GetToken(KotlinParserTRIPLE_QUOTE_CLOSE, 0) +} + +func (s *MultiLineStringLiteralContext) AllMultiLineStringContent() []IMultiLineStringContentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultiLineStringContentContext); ok { + len++ + } + } + + tst := make([]IMultiLineStringContentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultiLineStringContentContext); ok { + tst[i] = t.(IMultiLineStringContentContext) + i++ + } + } + + return tst +} + +func (s *MultiLineStringLiteralContext) MultiLineStringContent(i int) IMultiLineStringContentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiLineStringContentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultiLineStringContentContext) +} + +func (s *MultiLineStringLiteralContext) AllMultiLineStringExpression() []IMultiLineStringExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultiLineStringExpressionContext); ok { + len++ + } + } + + tst := make([]IMultiLineStringExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultiLineStringExpressionContext); ok { + tst[i] = t.(IMultiLineStringExpressionContext) + i++ + } + } + + return tst +} + +func (s *MultiLineStringLiteralContext) MultiLineStringExpression(i int) IMultiLineStringExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiLineStringExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultiLineStringExpressionContext) +} + +func (s *MultiLineStringLiteralContext) AllMultiLineStringQuote() []antlr.TerminalNode { + return s.GetTokens(KotlinParserMultiLineStringQuote) +} + +func (s *MultiLineStringLiteralContext) MultiLineStringQuote(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserMultiLineStringQuote, i) +} + +func (s *MultiLineStringLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiLineStringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiLineStringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiLineStringLiteral(s) + } +} + +func (s *MultiLineStringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiLineStringLiteral(s) + } +} + +func (p *KotlinParser) MultiLineStringLiteral() (localctx IMultiLineStringLiteralContext) { + this := p + _ = this + + localctx = NewMultiLineStringLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, KotlinParserRULE_multiLineStringLiteral) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2679) + p.Match(KotlinParserTRIPLE_QUOTE_OPEN) + } + p.SetState(2685) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for (int64((_la-165)) & ^0x3f) == 0 && ((int64(1)<<(_la-165))&15) != 0 { + p.SetState(2683) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 404, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2680) + p.MultiLineStringContent() + } + + case 2: + { + p.SetState(2681) + p.MultiLineStringExpression() + } + + case 3: + { + p.SetState(2682) + p.Match(KotlinParserMultiLineStringQuote) + } + + } + + p.SetState(2687) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2688) + p.Match(KotlinParserTRIPLE_QUOTE_CLOSE) + } + + return localctx +} + +// ILineStringContentContext is an interface to support dynamic dispatch. +type ILineStringContentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLineStringContentContext differentiates from other interfaces. + IsLineStringContentContext() +} + +type LineStringContentContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLineStringContentContext() *LineStringContentContext { + var p = new(LineStringContentContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_lineStringContent + return p +} + +func (*LineStringContentContext) IsLineStringContentContext() {} + +func NewLineStringContentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LineStringContentContext { + var p = new(LineStringContentContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_lineStringContent + + return p +} + +func (s *LineStringContentContext) GetParser() antlr.Parser { return s.parser } + +func (s *LineStringContentContext) LineStrText() antlr.TerminalNode { + return s.GetToken(KotlinParserLineStrText, 0) +} + +func (s *LineStringContentContext) LineStrEscapedChar() antlr.TerminalNode { + return s.GetToken(KotlinParserLineStrEscapedChar, 0) +} + +func (s *LineStringContentContext) LineStrRef() antlr.TerminalNode { + return s.GetToken(KotlinParserLineStrRef, 0) +} + +func (s *LineStringContentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LineStringContentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LineStringContentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLineStringContent(s) + } +} + +func (s *LineStringContentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLineStringContent(s) + } +} + +func (p *KotlinParser) LineStringContent() (localctx ILineStringContentContext) { + this := p + _ = this + + localctx = NewLineStringContentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, KotlinParserRULE_lineStringContent) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2690) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-160)) & ^0x3f) == 0 && ((int64(1)<<(_la-160))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// ILineStringExpressionContext is an interface to support dynamic dispatch. +type ILineStringExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLineStringExpressionContext differentiates from other interfaces. + IsLineStringExpressionContext() +} + +type LineStringExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLineStringExpressionContext() *LineStringExpressionContext { + var p = new(LineStringExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_lineStringExpression + return p +} + +func (*LineStringExpressionContext) IsLineStringExpressionContext() {} + +func NewLineStringExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LineStringExpressionContext { + var p = new(LineStringExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_lineStringExpression + + return p +} + +func (s *LineStringExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *LineStringExpressionContext) LineStrExprStart() antlr.TerminalNode { + return s.GetToken(KotlinParserLineStrExprStart, 0) +} + +func (s *LineStringExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LineStringExpressionContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *LineStringExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *LineStringExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *LineStringExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LineStringExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LineStringExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLineStringExpression(s) + } +} + +func (s *LineStringExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLineStringExpression(s) + } +} + +func (p *KotlinParser) LineStringExpression() (localctx ILineStringExpressionContext) { + this := p + _ = this + + localctx = NewLineStringExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, KotlinParserRULE_lineStringExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2692) + p.Match(KotlinParserLineStrExprStart) + } + p.SetState(2696) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2693) + p.Match(KotlinParserNL) + } + + p.SetState(2698) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2699) + p.Expression() + } + p.SetState(2703) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2700) + p.Match(KotlinParserNL) + } + + p.SetState(2705) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2706) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// IMultiLineStringContentContext is an interface to support dynamic dispatch. +type IMultiLineStringContentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiLineStringContentContext differentiates from other interfaces. + IsMultiLineStringContentContext() +} + +type MultiLineStringContentContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiLineStringContentContext() *MultiLineStringContentContext { + var p = new(MultiLineStringContentContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiLineStringContent + return p +} + +func (*MultiLineStringContentContext) IsMultiLineStringContentContext() {} + +func NewMultiLineStringContentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiLineStringContentContext { + var p = new(MultiLineStringContentContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiLineStringContent + + return p +} + +func (s *MultiLineStringContentContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiLineStringContentContext) MultiLineStrText() antlr.TerminalNode { + return s.GetToken(KotlinParserMultiLineStrText, 0) +} + +func (s *MultiLineStringContentContext) MultiLineStringQuote() antlr.TerminalNode { + return s.GetToken(KotlinParserMultiLineStringQuote, 0) +} + +func (s *MultiLineStringContentContext) MultiLineStrRef() antlr.TerminalNode { + return s.GetToken(KotlinParserMultiLineStrRef, 0) +} + +func (s *MultiLineStringContentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiLineStringContentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiLineStringContentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiLineStringContent(s) + } +} + +func (s *MultiLineStringContentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiLineStringContent(s) + } +} + +func (p *KotlinParser) MultiLineStringContent() (localctx IMultiLineStringContentContext) { + this := p + _ = this + + localctx = NewMultiLineStringContentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, KotlinParserRULE_multiLineStringContent) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2708) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-165)) & ^0x3f) == 0 && ((int64(1)<<(_la-165))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IMultiLineStringExpressionContext is an interface to support dynamic dispatch. +type IMultiLineStringExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiLineStringExpressionContext differentiates from other interfaces. + IsMultiLineStringExpressionContext() +} + +type MultiLineStringExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiLineStringExpressionContext() *MultiLineStringExpressionContext { + var p = new(MultiLineStringExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiLineStringExpression + return p +} + +func (*MultiLineStringExpressionContext) IsMultiLineStringExpressionContext() {} + +func NewMultiLineStringExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiLineStringExpressionContext { + var p = new(MultiLineStringExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiLineStringExpression + + return p +} + +func (s *MultiLineStringExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiLineStringExpressionContext) MultiLineStrExprStart() antlr.TerminalNode { + return s.GetToken(KotlinParserMultiLineStrExprStart, 0) +} + +func (s *MultiLineStringExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MultiLineStringExpressionContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *MultiLineStringExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *MultiLineStringExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *MultiLineStringExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiLineStringExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiLineStringExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiLineStringExpression(s) + } +} + +func (s *MultiLineStringExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiLineStringExpression(s) + } +} + +func (p *KotlinParser) MultiLineStringExpression() (localctx IMultiLineStringExpressionContext) { + this := p + _ = this + + localctx = NewMultiLineStringExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, KotlinParserRULE_multiLineStringExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2710) + p.Match(KotlinParserMultiLineStrExprStart) + } + p.SetState(2714) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2711) + p.Match(KotlinParserNL) + } + + p.SetState(2716) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2717) + p.Expression() + } + p.SetState(2721) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2718) + p.Match(KotlinParserNL) + } + + p.SetState(2723) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2724) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// ILambdaLiteralContext is an interface to support dynamic dispatch. +type ILambdaLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLambdaLiteralContext differentiates from other interfaces. + IsLambdaLiteralContext() +} + +type LambdaLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLambdaLiteralContext() *LambdaLiteralContext { + var p = new(LambdaLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_lambdaLiteral + return p +} + +func (*LambdaLiteralContext) IsLambdaLiteralContext() {} + +func NewLambdaLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaLiteralContext { + var p = new(LambdaLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_lambdaLiteral + + return p +} + +func (s *LambdaLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *LambdaLiteralContext) LCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserLCURL, 0) +} + +func (s *LambdaLiteralContext) Statements() IStatementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementsContext) +} + +func (s *LambdaLiteralContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *LambdaLiteralContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *LambdaLiteralContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *LambdaLiteralContext) ARROW() antlr.TerminalNode { + return s.GetToken(KotlinParserARROW, 0) +} + +func (s *LambdaLiteralContext) LambdaParameters() ILambdaParametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambdaParametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambdaParametersContext) +} + +func (s *LambdaLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LambdaLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LambdaLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLambdaLiteral(s) + } +} + +func (s *LambdaLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLambdaLiteral(s) + } +} + +func (p *KotlinParser) LambdaLiteral() (localctx ILambdaLiteralContext) { + this := p + _ = this + + localctx = NewLambdaLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, KotlinParserRULE_lambdaLiteral) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2726) + p.Match(KotlinParserLCURL) + } + p.SetState(2730) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 410, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2727) + p.Match(KotlinParserNL) + } + + } + p.SetState(2732) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 410, p.GetParserRuleContext()) + } + p.SetState(2749) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 414, p.GetParserRuleContext()) == 1 { + p.SetState(2734) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 411, p.GetParserRuleContext()) == 1 { + { + p.SetState(2733) + p.LambdaParameters() + } + + } + p.SetState(2739) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2736) + p.Match(KotlinParserNL) + } + + p.SetState(2741) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2742) + p.Match(KotlinParserARROW) + } + p.SetState(2746) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 413, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2743) + p.Match(KotlinParserNL) + } + + } + p.SetState(2748) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 413, p.GetParserRuleContext()) + } + + } + { + p.SetState(2751) + p.Statements() + } + p.SetState(2755) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2752) + p.Match(KotlinParserNL) + } + + p.SetState(2757) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2758) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// ILambdaParametersContext is an interface to support dynamic dispatch. +type ILambdaParametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLambdaParametersContext differentiates from other interfaces. + IsLambdaParametersContext() +} + +type LambdaParametersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLambdaParametersContext() *LambdaParametersContext { + var p = new(LambdaParametersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_lambdaParameters + return p +} + +func (*LambdaParametersContext) IsLambdaParametersContext() {} + +func NewLambdaParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaParametersContext { + var p = new(LambdaParametersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_lambdaParameters + + return p +} + +func (s *LambdaParametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *LambdaParametersContext) AllLambdaParameter() []ILambdaParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILambdaParameterContext); ok { + len++ + } + } + + tst := make([]ILambdaParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILambdaParameterContext); ok { + tst[i] = t.(ILambdaParameterContext) + i++ + } + } + + return tst +} + +func (s *LambdaParametersContext) LambdaParameter(i int) ILambdaParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambdaParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILambdaParameterContext) +} + +func (s *LambdaParametersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *LambdaParametersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *LambdaParametersContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *LambdaParametersContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *LambdaParametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LambdaParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LambdaParametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLambdaParameters(s) + } +} + +func (s *LambdaParametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLambdaParameters(s) + } +} + +func (p *KotlinParser) LambdaParameters() (localctx ILambdaParametersContext) { + this := p + _ = this + + localctx = NewLambdaParametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, KotlinParserRULE_lambdaParameters) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2760) + p.LambdaParameter() + } + p.SetState(2777) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 418, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2764) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2761) + p.Match(KotlinParserNL) + } + + p.SetState(2766) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2767) + p.Match(KotlinParserCOMMA) + } + p.SetState(2771) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 417, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2768) + p.Match(KotlinParserNL) + } + + } + p.SetState(2773) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 417, p.GetParserRuleContext()) + } + { + p.SetState(2774) + p.LambdaParameter() + } + + } + p.SetState(2779) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 418, p.GetParserRuleContext()) + } + p.SetState(2787) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 420, p.GetParserRuleContext()) == 1 { + p.SetState(2783) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2780) + p.Match(KotlinParserNL) + } + + p.SetState(2785) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2786) + p.Match(KotlinParserCOMMA) + } + + } + + return localctx +} + +// ILambdaParameterContext is an interface to support dynamic dispatch. +type ILambdaParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsLambdaParameterContext differentiates from other interfaces. + IsLambdaParameterContext() +} + +type LambdaParameterContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLambdaParameterContext() *LambdaParameterContext { + var p = new(LambdaParameterContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_lambdaParameter + return p +} + +func (*LambdaParameterContext) IsLambdaParameterContext() {} + +func NewLambdaParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaParameterContext { + var p = new(LambdaParameterContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_lambdaParameter + + return p +} + +func (s *LambdaParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *LambdaParameterContext) VariableDeclaration() IVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableDeclarationContext) +} + +func (s *LambdaParameterContext) MultiVariableDeclaration() IMultiVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiVariableDeclarationContext) +} + +func (s *LambdaParameterContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *LambdaParameterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *LambdaParameterContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *LambdaParameterContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *LambdaParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LambdaParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LambdaParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterLambdaParameter(s) + } +} + +func (s *LambdaParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitLambdaParameter(s) + } +} + +func (p *KotlinParser) LambdaParameter() (localctx ILambdaParameterContext) { + this := p + _ = this + + localctx = NewLambdaParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, KotlinParserRULE_lambdaParameter) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2807) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserNL, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2789) + p.VariableDeclaration() + } + + case KotlinParserLPAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2790) + p.MultiVariableDeclaration() + } + p.SetState(2805) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 423, p.GetParserRuleContext()) == 1 { + p.SetState(2794) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2791) + p.Match(KotlinParserNL) + } + + p.SetState(2796) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2797) + p.Match(KotlinParserCOLON) + } + p.SetState(2801) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2798) + p.Match(KotlinParserNL) + } + + p.SetState(2803) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2804) + p.Type_() + } + + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IAnonymousFunctionContext is an interface to support dynamic dispatch. +type IAnonymousFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAnonymousFunctionContext differentiates from other interfaces. + IsAnonymousFunctionContext() +} + +type AnonymousFunctionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnonymousFunctionContext() *AnonymousFunctionContext { + var p = new(AnonymousFunctionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_anonymousFunction + return p +} + +func (*AnonymousFunctionContext) IsAnonymousFunctionContext() {} + +func NewAnonymousFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousFunctionContext { + var p = new(AnonymousFunctionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_anonymousFunction + + return p +} + +func (s *AnonymousFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnonymousFunctionContext) FUN() antlr.TerminalNode { + return s.GetToken(KotlinParserFUN, 0) +} + +func (s *AnonymousFunctionContext) ParametersWithOptionalType() IParametersWithOptionalTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParametersWithOptionalTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParametersWithOptionalTypeContext) +} + +func (s *AnonymousFunctionContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *AnonymousFunctionContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *AnonymousFunctionContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *AnonymousFunctionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AnonymousFunctionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AnonymousFunctionContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *AnonymousFunctionContext) TypeConstraints() ITypeConstraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeConstraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeConstraintsContext) +} + +func (s *AnonymousFunctionContext) FunctionBody() IFunctionBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionBodyContext) +} + +func (s *AnonymousFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnonymousFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnonymousFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAnonymousFunction(s) + } +} + +func (s *AnonymousFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAnonymousFunction(s) + } +} + +func (p *KotlinParser) AnonymousFunction() (localctx IAnonymousFunctionContext) { + this := p + _ = this + + localctx = NewAnonymousFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, KotlinParserRULE_anonymousFunction) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2809) + p.Match(KotlinParserFUN) + } + p.SetState(2825) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 427, p.GetParserRuleContext()) == 1 { + p.SetState(2813) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2810) + p.Match(KotlinParserNL) + } + + p.SetState(2815) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2816) + p.Type_() + } + p.SetState(2820) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2817) + p.Match(KotlinParserNL) + } + + p.SetState(2822) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2823) + p.Match(KotlinParserDOT) + } + + } + p.SetState(2830) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2827) + p.Match(KotlinParserNL) + } + + p.SetState(2832) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2833) + p.ParametersWithOptionalType() + } + p.SetState(2848) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 431, p.GetParserRuleContext()) == 1 { + p.SetState(2837) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2834) + p.Match(KotlinParserNL) + } + + p.SetState(2839) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2840) + p.Match(KotlinParserCOLON) + } + p.SetState(2844) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2841) + p.Match(KotlinParserNL) + } + + p.SetState(2846) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2847) + p.Type_() + } + + } + p.SetState(2857) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 433, p.GetParserRuleContext()) == 1 { + p.SetState(2853) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2850) + p.Match(KotlinParserNL) + } + + p.SetState(2855) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2856) + p.TypeConstraints() + } + + } + p.SetState(2866) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 435, p.GetParserRuleContext()) == 1 { + p.SetState(2862) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2859) + p.Match(KotlinParserNL) + } + + p.SetState(2864) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2865) + p.FunctionBody() + } + + } + + return localctx +} + +// IFunctionLiteralContext is an interface to support dynamic dispatch. +type IFunctionLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionLiteralContext differentiates from other interfaces. + IsFunctionLiteralContext() +} + +type FunctionLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionLiteralContext() *FunctionLiteralContext { + var p = new(FunctionLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionLiteral + return p +} + +func (*FunctionLiteralContext) IsFunctionLiteralContext() {} + +func NewFunctionLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionLiteralContext { + var p = new(FunctionLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionLiteral + + return p +} + +func (s *FunctionLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionLiteralContext) LambdaLiteral() ILambdaLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambdaLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambdaLiteralContext) +} + +func (s *FunctionLiteralContext) AnonymousFunction() IAnonymousFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnonymousFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnonymousFunctionContext) +} + +func (s *FunctionLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionLiteral(s) + } +} + +func (s *FunctionLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionLiteral(s) + } +} + +func (p *KotlinParser) FunctionLiteral() (localctx IFunctionLiteralContext) { + this := p + _ = this + + localctx = NewFunctionLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, KotlinParserRULE_functionLiteral) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2870) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLCURL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2868) + p.LambdaLiteral() + } + + case KotlinParserFUN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2869) + p.AnonymousFunction() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IObjectLiteralContext is an interface to support dynamic dispatch. +type IObjectLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsObjectLiteralContext differentiates from other interfaces. + IsObjectLiteralContext() +} + +type ObjectLiteralContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObjectLiteralContext() *ObjectLiteralContext { + var p = new(ObjectLiteralContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_objectLiteral + return p +} + +func (*ObjectLiteralContext) IsObjectLiteralContext() {} + +func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext { + var p = new(ObjectLiteralContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_objectLiteral + + return p +} + +func (s *ObjectLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *ObjectLiteralContext) OBJECT() antlr.TerminalNode { + return s.GetToken(KotlinParserOBJECT, 0) +} + +func (s *ObjectLiteralContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *ObjectLiteralContext) DelegationSpecifiers() IDelegationSpecifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelegationSpecifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelegationSpecifiersContext) +} + +func (s *ObjectLiteralContext) ClassBody() IClassBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassBodyContext) +} + +func (s *ObjectLiteralContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ObjectLiteralContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ObjectLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ObjectLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ObjectLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterObjectLiteral(s) + } +} + +func (s *ObjectLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitObjectLiteral(s) + } +} + +func (p *KotlinParser) ObjectLiteral() (localctx IObjectLiteralContext) { + this := p + _ = this + + localctx = NewObjectLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, KotlinParserRULE_objectLiteral) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2872) + p.Match(KotlinParserOBJECT) + } + p.SetState(2893) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 { + p.SetState(2876) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2873) + p.Match(KotlinParserNL) + } + + p.SetState(2878) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2879) + p.Match(KotlinParserCOLON) + } + p.SetState(2883) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 438, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2880) + p.Match(KotlinParserNL) + } + + } + p.SetState(2885) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 438, p.GetParserRuleContext()) + } + { + p.SetState(2886) + p.DelegationSpecifiers() + } + p.SetState(2890) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 439, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2887) + p.Match(KotlinParserNL) + } + + } + p.SetState(2892) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 439, p.GetParserRuleContext()) + } + + } + p.SetState(2902) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 { + p.SetState(2898) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2895) + p.Match(KotlinParserNL) + } + + p.SetState(2900) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2901) + p.ClassBody() + } + + } + + return localctx +} + +// IThisExpressionContext is an interface to support dynamic dispatch. +type IThisExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsThisExpressionContext differentiates from other interfaces. + IsThisExpressionContext() +} + +type ThisExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyThisExpressionContext() *ThisExpressionContext { + var p = new(ThisExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_thisExpression + return p +} + +func (*ThisExpressionContext) IsThisExpressionContext() {} + +func NewThisExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThisExpressionContext { + var p = new(ThisExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_thisExpression + + return p +} + +func (s *ThisExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ThisExpressionContext) THIS() antlr.TerminalNode { + return s.GetToken(KotlinParserTHIS, 0) +} + +func (s *ThisExpressionContext) THIS_AT() antlr.TerminalNode { + return s.GetToken(KotlinParserTHIS_AT, 0) +} + +func (s *ThisExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ThisExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ThisExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterThisExpression(s) + } +} + +func (s *ThisExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitThisExpression(s) + } +} + +func (p *KotlinParser) ThisExpression() (localctx IThisExpressionContext) { + this := p + _ = this + + localctx = NewThisExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, KotlinParserRULE_thisExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2904) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserTHIS_AT || _la == KotlinParserTHIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// ISuperExpressionContext is an interface to support dynamic dispatch. +type ISuperExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSuperExpressionContext differentiates from other interfaces. + IsSuperExpressionContext() +} + +type SuperExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySuperExpressionContext() *SuperExpressionContext { + var p = new(SuperExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_superExpression + return p +} + +func (*SuperExpressionContext) IsSuperExpressionContext() {} + +func NewSuperExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SuperExpressionContext { + var p = new(SuperExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_superExpression + + return p +} + +func (s *SuperExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SuperExpressionContext) SUPER() antlr.TerminalNode { + return s.GetToken(KotlinParserSUPER, 0) +} + +func (s *SuperExpressionContext) LANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserLANGLE, 0) +} + +func (s *SuperExpressionContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *SuperExpressionContext) RANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserRANGLE, 0) +} + +func (s *SuperExpressionContext) AT_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_NO_WS, 0) +} + +func (s *SuperExpressionContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *SuperExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SuperExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SuperExpressionContext) SUPER_AT() antlr.TerminalNode { + return s.GetToken(KotlinParserSUPER_AT, 0) +} + +func (s *SuperExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SuperExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SuperExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSuperExpression(s) + } +} + +func (s *SuperExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSuperExpression(s) + } +} + +func (p *KotlinParser) SuperExpression() (localctx ISuperExpressionContext) { + this := p + _ = this + + localctx = NewSuperExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, KotlinParserRULE_superExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(2930) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserSUPER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2906) + p.Match(KotlinParserSUPER) + } + p.SetState(2923) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 445, p.GetParserRuleContext()) == 1 { + { + p.SetState(2907) + p.Match(KotlinParserLANGLE) + } + p.SetState(2911) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2908) + p.Match(KotlinParserNL) + } + + p.SetState(2913) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2914) + p.Type_() + } + p.SetState(2918) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2915) + p.Match(KotlinParserNL) + } + + p.SetState(2920) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2921) + p.Match(KotlinParserRANGLE) + } + + } + p.SetState(2927) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 446, p.GetParserRuleContext()) == 1 { + { + p.SetState(2925) + p.Match(KotlinParserAT_NO_WS) + } + { + p.SetState(2926) + p.SimpleIdentifier() + } + + } + + case KotlinParserSUPER_AT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2929) + p.Match(KotlinParserSUPER_AT) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IIfExpressionContext is an interface to support dynamic dispatch. +type IIfExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsIfExpressionContext differentiates from other interfaces. + IsIfExpressionContext() +} + +type IfExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfExpressionContext() *IfExpressionContext { + var p = new(IfExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_ifExpression + return p +} + +func (*IfExpressionContext) IsIfExpressionContext() {} + +func NewIfExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfExpressionContext { + var p = new(IfExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_ifExpression + + return p +} + +func (s *IfExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfExpressionContext) IF() antlr.TerminalNode { + return s.GetToken(KotlinParserIF, 0) +} + +func (s *IfExpressionContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *IfExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IfExpressionContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *IfExpressionContext) AllControlStructureBody() []IControlStructureBodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IControlStructureBodyContext); ok { + len++ + } + } + + tst := make([]IControlStructureBodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IControlStructureBodyContext); ok { + tst[i] = t.(IControlStructureBodyContext) + i++ + } + } + + return tst +} + +func (s *IfExpressionContext) ControlStructureBody(i int) IControlStructureBodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlStructureBodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IControlStructureBodyContext) +} + +func (s *IfExpressionContext) ELSE() antlr.TerminalNode { + return s.GetToken(KotlinParserELSE, 0) +} + +func (s *IfExpressionContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(KotlinParserSEMICOLON) +} + +func (s *IfExpressionContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserSEMICOLON, i) +} + +func (s *IfExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *IfExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *IfExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterIfExpression(s) + } +} + +func (s *IfExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitIfExpression(s) + } +} + +func (p *KotlinParser) IfExpression() (localctx IIfExpressionContext) { + this := p + _ = this + + localctx = NewIfExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, KotlinParserRULE_ifExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2932) + p.Match(KotlinParserIF) + } + p.SetState(2936) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2933) + p.Match(KotlinParserNL) + } + + p.SetState(2938) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2939) + p.Match(KotlinParserLPAREN) + } + p.SetState(2943) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2940) + p.Match(KotlinParserNL) + } + + p.SetState(2945) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2946) + p.Expression() + } + p.SetState(2950) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2947) + p.Match(KotlinParserNL) + } + + p.SetState(2952) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2953) + p.Match(KotlinParserRPAREN) + } + p.SetState(2957) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 451, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2954) + p.Match(KotlinParserNL) + } + + } + p.SetState(2959) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 451, p.GetParserRuleContext()) + } + p.SetState(2991) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 458, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2960) + p.ControlStructureBody() + } + + case 2: + p.SetState(2962) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-144109553024488960) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-4260645306497) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&13629951) != 0 { + { + p.SetState(2961) + p.ControlStructureBody() + } + + } + p.SetState(2967) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 453, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2964) + p.Match(KotlinParserNL) + } + + } + p.SetState(2969) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 453, p.GetParserRuleContext()) + } + p.SetState(2971) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserSEMICOLON { + { + p.SetState(2970) + p.Match(KotlinParserSEMICOLON) + } + + } + p.SetState(2976) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2973) + p.Match(KotlinParserNL) + } + + p.SetState(2978) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2979) + p.Match(KotlinParserELSE) + } + p.SetState(2983) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(2980) + p.Match(KotlinParserNL) + } + + p.SetState(2985) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(2988) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLPAREN, KotlinParserLSQUARE, KotlinParserLCURL, KotlinParserADD, KotlinParserSUB, KotlinParserINCR, KotlinParserDECR, KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS, KotlinParserCOLONCOLON, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserRETURN_AT, KotlinParserCONTINUE_AT, KotlinParserBREAK_AT, KotlinParserTHIS_AT, KotlinParserSUPER_AT, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCLASS, KotlinParserINTERFACE, KotlinParserFUN, KotlinParserOBJECT, KotlinParserVAL, KotlinParserVAR, KotlinParserTYPE_ALIAS, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserTHIS, KotlinParserSUPER, KotlinParserWHERE, KotlinParserIF, KotlinParserWHEN, KotlinParserTRY, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserFOR, KotlinParserDO, KotlinParserWHILE, KotlinParserTHROW, KotlinParserRETURN, KotlinParserCONTINUE, KotlinParserBREAK, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserRealLiteral, KotlinParserIntegerLiteral, KotlinParserHexLiteral, KotlinParserBinLiteral, KotlinParserUnsignedLiteral, KotlinParserLongLiteral, KotlinParserBooleanLiteral, KotlinParserNullLiteral, KotlinParserCharacterLiteral, KotlinParserIdentifier, KotlinParserQUOTE_OPEN, KotlinParserTRIPLE_QUOTE_OPEN: + { + p.SetState(2986) + p.ControlStructureBody() + } + + case KotlinParserSEMICOLON: + { + p.SetState(2987) + p.Match(KotlinParserSEMICOLON) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + case 3: + { + p.SetState(2990) + p.Match(KotlinParserSEMICOLON) + } + + } + + return localctx +} + +// IWhenSubjectContext is an interface to support dynamic dispatch. +type IWhenSubjectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsWhenSubjectContext differentiates from other interfaces. + IsWhenSubjectContext() +} + +type WhenSubjectContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhenSubjectContext() *WhenSubjectContext { + var p = new(WhenSubjectContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_whenSubject + return p +} + +func (*WhenSubjectContext) IsWhenSubjectContext() {} + +func NewWhenSubjectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenSubjectContext { + var p = new(WhenSubjectContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_whenSubject + + return p +} + +func (s *WhenSubjectContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhenSubjectContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *WhenSubjectContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WhenSubjectContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *WhenSubjectContext) VAL() antlr.TerminalNode { + return s.GetToken(KotlinParserVAL, 0) +} + +func (s *WhenSubjectContext) VariableDeclaration() IVariableDeclarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableDeclarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableDeclarationContext) +} + +func (s *WhenSubjectContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserASSIGNMENT, 0) +} + +func (s *WhenSubjectContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *WhenSubjectContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *WhenSubjectContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *WhenSubjectContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *WhenSubjectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhenSubjectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhenSubjectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterWhenSubject(s) + } +} + +func (s *WhenSubjectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitWhenSubject(s) + } +} + +func (p *KotlinParser) WhenSubject() (localctx IWhenSubjectContext) { + this := p + _ = this + + localctx = NewWhenSubjectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, KotlinParserRULE_whenSubject) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2993) + p.Match(KotlinParserLPAREN) + } + p.SetState(3027) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 464, p.GetParserRuleContext()) == 1 { + p.SetState(2997) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS { + { + p.SetState(2994) + p.Annotation() + } + + p.SetState(2999) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(3003) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3000) + p.Match(KotlinParserNL) + } + + p.SetState(3005) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3006) + p.Match(KotlinParserVAL) + } + p.SetState(3010) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 461, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3007) + p.Match(KotlinParserNL) + } + + } + p.SetState(3012) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 461, p.GetParserRuleContext()) + } + { + p.SetState(3013) + p.VariableDeclaration() + } + p.SetState(3017) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3014) + p.Match(KotlinParserNL) + } + + p.SetState(3019) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3020) + p.Match(KotlinParserASSIGNMENT) + } + p.SetState(3024) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3021) + p.Match(KotlinParserNL) + } + + p.SetState(3026) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(3029) + p.Expression() + } + { + p.SetState(3030) + p.Match(KotlinParserRPAREN) + } + + return localctx +} + +// IWhenExpressionContext is an interface to support dynamic dispatch. +type IWhenExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsWhenExpressionContext differentiates from other interfaces. + IsWhenExpressionContext() +} + +type WhenExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhenExpressionContext() *WhenExpressionContext { + var p = new(WhenExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_whenExpression + return p +} + +func (*WhenExpressionContext) IsWhenExpressionContext() {} + +func NewWhenExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenExpressionContext { + var p = new(WhenExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_whenExpression + + return p +} + +func (s *WhenExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhenExpressionContext) WHEN() antlr.TerminalNode { + return s.GetToken(KotlinParserWHEN, 0) +} + +func (s *WhenExpressionContext) LCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserLCURL, 0) +} + +func (s *WhenExpressionContext) RCURL() antlr.TerminalNode { + return s.GetToken(KotlinParserRCURL, 0) +} + +func (s *WhenExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *WhenExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *WhenExpressionContext) WhenSubject() IWhenSubjectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenSubjectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhenSubjectContext) +} + +func (s *WhenExpressionContext) AllWhenEntry() []IWhenEntryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWhenEntryContext); ok { + len++ + } + } + + tst := make([]IWhenEntryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWhenEntryContext); ok { + tst[i] = t.(IWhenEntryContext) + i++ + } + } + + return tst +} + +func (s *WhenExpressionContext) WhenEntry(i int) IWhenEntryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenEntryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWhenEntryContext) +} + +func (s *WhenExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhenExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhenExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterWhenExpression(s) + } +} + +func (s *WhenExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitWhenExpression(s) + } +} + +func (p *KotlinParser) WhenExpression() (localctx IWhenExpressionContext) { + this := p + _ = this + + localctx = NewWhenExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, KotlinParserRULE_whenExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3032) + p.Match(KotlinParserWHEN) + } + p.SetState(3036) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 465, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3033) + p.Match(KotlinParserNL) + } + + } + p.SetState(3038) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 465, p.GetParserRuleContext()) + } + p.SetState(3040) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserLPAREN { + { + p.SetState(3039) + p.WhenSubject() + } + + } + p.SetState(3045) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3042) + p.Match(KotlinParserNL) + } + + p.SetState(3047) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3048) + p.Match(KotlinParserLCURL) + } + p.SetState(3052) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 468, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3049) + p.Match(KotlinParserNL) + } + + } + p.SetState(3054) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 468, p.GetParserRuleContext()) + } + p.SetState(3064) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-144109553024488960) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-144959399553) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&13629951) != 0 { + { + p.SetState(3055) + p.WhenEntry() + } + p.SetState(3059) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 469, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3056) + p.Match(KotlinParserNL) + } + + } + p.SetState(3061) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 469, p.GetParserRuleContext()) + } + + p.SetState(3066) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(3070) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3067) + p.Match(KotlinParserNL) + } + + p.SetState(3072) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3073) + p.Match(KotlinParserRCURL) + } + + return localctx +} + +// IWhenEntryContext is an interface to support dynamic dispatch. +type IWhenEntryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsWhenEntryContext differentiates from other interfaces. + IsWhenEntryContext() +} + +type WhenEntryContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhenEntryContext() *WhenEntryContext { + var p = new(WhenEntryContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_whenEntry + return p +} + +func (*WhenEntryContext) IsWhenEntryContext() {} + +func NewWhenEntryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenEntryContext { + var p = new(WhenEntryContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_whenEntry + + return p +} + +func (s *WhenEntryContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhenEntryContext) AllWhenCondition() []IWhenConditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWhenConditionContext); ok { + len++ + } + } + + tst := make([]IWhenConditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWhenConditionContext); ok { + tst[i] = t.(IWhenConditionContext) + i++ + } + } + + return tst +} + +func (s *WhenEntryContext) WhenCondition(i int) IWhenConditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenConditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWhenConditionContext) +} + +func (s *WhenEntryContext) ARROW() antlr.TerminalNode { + return s.GetToken(KotlinParserARROW, 0) +} + +func (s *WhenEntryContext) ControlStructureBody() IControlStructureBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlStructureBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IControlStructureBodyContext) +} + +func (s *WhenEntryContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(KotlinParserCOMMA) +} + +func (s *WhenEntryContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, i) +} + +func (s *WhenEntryContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *WhenEntryContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *WhenEntryContext) Semi() ISemiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISemiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISemiContext) +} + +func (s *WhenEntryContext) ELSE() antlr.TerminalNode { + return s.GetToken(KotlinParserELSE, 0) +} + +func (s *WhenEntryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhenEntryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhenEntryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterWhenEntry(s) + } +} + +func (s *WhenEntryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitWhenEntry(s) + } +} + +func (p *KotlinParser) WhenEntry() (localctx IWhenEntryContext) { + this := p + _ = this + + localctx = NewWhenEntryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, KotlinParserRULE_whenEntry) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.SetState(3139) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLPAREN, KotlinParserLSQUARE, KotlinParserLCURL, KotlinParserADD, KotlinParserSUB, KotlinParserINCR, KotlinParserDECR, KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS, KotlinParserCOLONCOLON, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserRETURN_AT, KotlinParserCONTINUE_AT, KotlinParserBREAK_AT, KotlinParserTHIS_AT, KotlinParserSUPER_AT, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserFUN, KotlinParserOBJECT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserTHIS, KotlinParserSUPER, KotlinParserWHERE, KotlinParserIF, KotlinParserWHEN, KotlinParserTRY, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserTHROW, KotlinParserRETURN, KotlinParserCONTINUE, KotlinParserBREAK, KotlinParserIS, KotlinParserIN, KotlinParserNOT_IS, KotlinParserNOT_IN, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserRealLiteral, KotlinParserIntegerLiteral, KotlinParserHexLiteral, KotlinParserBinLiteral, KotlinParserUnsignedLiteral, KotlinParserLongLiteral, KotlinParserBooleanLiteral, KotlinParserNullLiteral, KotlinParserCharacterLiteral, KotlinParserIdentifier, KotlinParserQUOTE_OPEN, KotlinParserTRIPLE_QUOTE_OPEN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3075) + p.WhenCondition() + } + p.SetState(3092) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 474, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3079) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3076) + p.Match(KotlinParserNL) + } + + p.SetState(3081) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3082) + p.Match(KotlinParserCOMMA) + } + p.SetState(3086) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3083) + p.Match(KotlinParserNL) + } + + p.SetState(3088) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3089) + p.WhenCondition() + } + + } + p.SetState(3094) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 474, p.GetParserRuleContext()) + } + p.SetState(3102) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 476, p.GetParserRuleContext()) == 1 { + p.SetState(3098) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3095) + p.Match(KotlinParserNL) + } + + p.SetState(3100) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3101) + p.Match(KotlinParserCOMMA) + } + + } + p.SetState(3107) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3104) + p.Match(KotlinParserNL) + } + + p.SetState(3109) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3110) + p.Match(KotlinParserARROW) + } + p.SetState(3114) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3111) + p.Match(KotlinParserNL) + } + + p.SetState(3116) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3117) + p.ControlStructureBody() + } + p.SetState(3119) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 479, p.GetParserRuleContext()) == 1 { + { + p.SetState(3118) + p.Semi() + } + + } + + case KotlinParserELSE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3121) + p.Match(KotlinParserELSE) + } + p.SetState(3125) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3122) + p.Match(KotlinParserNL) + } + + p.SetState(3127) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3128) + p.Match(KotlinParserARROW) + } + p.SetState(3132) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3129) + p.Match(KotlinParserNL) + } + + p.SetState(3134) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3135) + p.ControlStructureBody() + } + p.SetState(3137) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 482, p.GetParserRuleContext()) == 1 { + { + p.SetState(3136) + p.Semi() + } + + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IWhenConditionContext is an interface to support dynamic dispatch. +type IWhenConditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsWhenConditionContext differentiates from other interfaces. + IsWhenConditionContext() +} + +type WhenConditionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhenConditionContext() *WhenConditionContext { + var p = new(WhenConditionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_whenCondition + return p +} + +func (*WhenConditionContext) IsWhenConditionContext() {} + +func NewWhenConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenConditionContext { + var p = new(WhenConditionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_whenCondition + + return p +} + +func (s *WhenConditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhenConditionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WhenConditionContext) RangeTest() IRangeTestContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRangeTestContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRangeTestContext) +} + +func (s *WhenConditionContext) TypeTest() ITypeTestContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeTestContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeTestContext) +} + +func (s *WhenConditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhenConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhenConditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterWhenCondition(s) + } +} + +func (s *WhenConditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitWhenCondition(s) + } +} + +func (p *KotlinParser) WhenCondition() (localctx IWhenConditionContext) { + this := p + _ = this + + localctx = NewWhenConditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, KotlinParserRULE_whenCondition) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3144) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserLPAREN, KotlinParserLSQUARE, KotlinParserLCURL, KotlinParserADD, KotlinParserSUB, KotlinParserINCR, KotlinParserDECR, KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS, KotlinParserCOLONCOLON, KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS, KotlinParserRETURN_AT, KotlinParserCONTINUE_AT, KotlinParserBREAK_AT, KotlinParserTHIS_AT, KotlinParserSUPER_AT, KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserFUN, KotlinParserOBJECT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserTHIS, KotlinParserSUPER, KotlinParserWHERE, KotlinParserIF, KotlinParserWHEN, KotlinParserTRY, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserTHROW, KotlinParserRETURN, KotlinParserCONTINUE, KotlinParserBREAK, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserRealLiteral, KotlinParserIntegerLiteral, KotlinParserHexLiteral, KotlinParserBinLiteral, KotlinParserUnsignedLiteral, KotlinParserLongLiteral, KotlinParserBooleanLiteral, KotlinParserNullLiteral, KotlinParserCharacterLiteral, KotlinParserIdentifier, KotlinParserQUOTE_OPEN, KotlinParserTRIPLE_QUOTE_OPEN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3141) + p.Expression() + } + + case KotlinParserIN, KotlinParserNOT_IN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3142) + p.RangeTest() + } + + case KotlinParserIS, KotlinParserNOT_IS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3143) + p.TypeTest() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IRangeTestContext is an interface to support dynamic dispatch. +type IRangeTestContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsRangeTestContext differentiates from other interfaces. + IsRangeTestContext() +} + +type RangeTestContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRangeTestContext() *RangeTestContext { + var p = new(RangeTestContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_rangeTest + return p +} + +func (*RangeTestContext) IsRangeTestContext() {} + +func NewRangeTestContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeTestContext { + var p = new(RangeTestContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_rangeTest + + return p +} + +func (s *RangeTestContext) GetParser() antlr.Parser { return s.parser } + +func (s *RangeTestContext) InOperator() IInOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInOperatorContext) +} + +func (s *RangeTestContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *RangeTestContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *RangeTestContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *RangeTestContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RangeTestContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RangeTestContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterRangeTest(s) + } +} + +func (s *RangeTestContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitRangeTest(s) + } +} + +func (p *KotlinParser) RangeTest() (localctx IRangeTestContext) { + this := p + _ = this + + localctx = NewRangeTestContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, KotlinParserRULE_rangeTest) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3146) + p.InOperator() + } + p.SetState(3150) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3147) + p.Match(KotlinParserNL) + } + + p.SetState(3152) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3153) + p.Expression() + } + + return localctx +} + +// ITypeTestContext is an interface to support dynamic dispatch. +type ITypeTestContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeTestContext differentiates from other interfaces. + IsTypeTestContext() +} + +type TypeTestContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeTestContext() *TypeTestContext { + var p = new(TypeTestContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeTest + return p +} + +func (*TypeTestContext) IsTypeTestContext() {} + +func NewTypeTestContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeTestContext { + var p = new(TypeTestContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeTest + + return p +} + +func (s *TypeTestContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeTestContext) IsOperator() IIsOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIsOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIsOperatorContext) +} + +func (s *TypeTestContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *TypeTestContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeTestContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeTestContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeTestContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeTestContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeTest(s) + } +} + +func (s *TypeTestContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeTest(s) + } +} + +func (p *KotlinParser) TypeTest() (localctx ITypeTestContext) { + this := p + _ = this + + localctx = NewTypeTestContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, KotlinParserRULE_typeTest) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3155) + p.IsOperator() + } + p.SetState(3159) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3156) + p.Match(KotlinParserNL) + } + + p.SetState(3161) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3162) + p.Type_() + } + + return localctx +} + +// ITryExpressionContext is an interface to support dynamic dispatch. +type ITryExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTryExpressionContext differentiates from other interfaces. + IsTryExpressionContext() +} + +type TryExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTryExpressionContext() *TryExpressionContext { + var p = new(TryExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_tryExpression + return p +} + +func (*TryExpressionContext) IsTryExpressionContext() {} + +func NewTryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryExpressionContext { + var p = new(TryExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_tryExpression + + return p +} + +func (s *TryExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TryExpressionContext) TRY() antlr.TerminalNode { + return s.GetToken(KotlinParserTRY, 0) +} + +func (s *TryExpressionContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *TryExpressionContext) FinallyBlock() IFinallyBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFinallyBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFinallyBlockContext) +} + +func (s *TryExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TryExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TryExpressionContext) AllCatchBlock() []ICatchBlockContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICatchBlockContext); ok { + len++ + } + } + + tst := make([]ICatchBlockContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICatchBlockContext); ok { + tst[i] = t.(ICatchBlockContext) + i++ + } + } + + return tst +} + +func (s *TryExpressionContext) CatchBlock(i int) ICatchBlockContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICatchBlockContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICatchBlockContext) +} + +func (s *TryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTryExpression(s) + } +} + +func (s *TryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTryExpression(s) + } +} + +func (p *KotlinParser) TryExpression() (localctx ITryExpressionContext) { + this := p + _ = this + + localctx = NewTryExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, KotlinParserRULE_tryExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3164) + p.Match(KotlinParserTRY) + } + p.SetState(3168) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3165) + p.Match(KotlinParserNL) + } + + p.SetState(3170) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3171) + p.Block() + } + p.SetState(3199) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 493, p.GetParserRuleContext()) { + case 1: + p.SetState(3179) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3175) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3172) + p.Match(KotlinParserNL) + } + + p.SetState(3177) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3178) + p.CatchBlock() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(3181) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 489, p.GetParserRuleContext()) + } + p.SetState(3190) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 491, p.GetParserRuleContext()) == 1 { + p.SetState(3186) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3183) + p.Match(KotlinParserNL) + } + + p.SetState(3188) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3189) + p.FinallyBlock() + } + + } + + case 2: + p.SetState(3195) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3192) + p.Match(KotlinParserNL) + } + + p.SetState(3197) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3198) + p.FinallyBlock() + } + + } + + return localctx +} + +// ICatchBlockContext is an interface to support dynamic dispatch. +type ICatchBlockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsCatchBlockContext differentiates from other interfaces. + IsCatchBlockContext() +} + +type CatchBlockContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCatchBlockContext() *CatchBlockContext { + var p = new(CatchBlockContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_catchBlock + return p +} + +func (*CatchBlockContext) IsCatchBlockContext() {} + +func NewCatchBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchBlockContext { + var p = new(CatchBlockContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_catchBlock + + return p +} + +func (s *CatchBlockContext) GetParser() antlr.Parser { return s.parser } + +func (s *CatchBlockContext) CATCH() antlr.TerminalNode { + return s.GetToken(KotlinParserCATCH, 0) +} + +func (s *CatchBlockContext) LPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserLPAREN, 0) +} + +func (s *CatchBlockContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *CatchBlockContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *CatchBlockContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *CatchBlockContext) RPAREN() antlr.TerminalNode { + return s.GetToken(KotlinParserRPAREN, 0) +} + +func (s *CatchBlockContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *CatchBlockContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *CatchBlockContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *CatchBlockContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *CatchBlockContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *CatchBlockContext) COMMA() antlr.TerminalNode { + return s.GetToken(KotlinParserCOMMA, 0) +} + +func (s *CatchBlockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CatchBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CatchBlockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterCatchBlock(s) + } +} + +func (s *CatchBlockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitCatchBlock(s) + } +} + +func (p *KotlinParser) CatchBlock() (localctx ICatchBlockContext) { + this := p + _ = this + + localctx = NewCatchBlockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, KotlinParserRULE_catchBlock) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3201) + p.Match(KotlinParserCATCH) + } + p.SetState(3205) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3202) + p.Match(KotlinParserNL) + } + + p.SetState(3207) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3208) + p.Match(KotlinParserLPAREN) + } + p.SetState(3212) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS { + { + p.SetState(3209) + p.Annotation() + } + + p.SetState(3214) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3215) + p.SimpleIdentifier() + } + { + p.SetState(3216) + p.Match(KotlinParserCOLON) + } + { + p.SetState(3217) + p.Type_() + } + p.SetState(3225) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if _la == KotlinParserNL || _la == KotlinParserCOMMA { + p.SetState(3221) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3218) + p.Match(KotlinParserNL) + } + + p.SetState(3223) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3224) + p.Match(KotlinParserCOMMA) + } + + } + { + p.SetState(3227) + p.Match(KotlinParserRPAREN) + } + p.SetState(3231) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3228) + p.Match(KotlinParserNL) + } + + p.SetState(3233) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3234) + p.Block() + } + + return localctx +} + +// IFinallyBlockContext is an interface to support dynamic dispatch. +type IFinallyBlockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFinallyBlockContext differentiates from other interfaces. + IsFinallyBlockContext() +} + +type FinallyBlockContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFinallyBlockContext() *FinallyBlockContext { + var p = new(FinallyBlockContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_finallyBlock + return p +} + +func (*FinallyBlockContext) IsFinallyBlockContext() {} + +func NewFinallyBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FinallyBlockContext { + var p = new(FinallyBlockContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_finallyBlock + + return p +} + +func (s *FinallyBlockContext) GetParser() antlr.Parser { return s.parser } + +func (s *FinallyBlockContext) FINALLY() antlr.TerminalNode { + return s.GetToken(KotlinParserFINALLY, 0) +} + +func (s *FinallyBlockContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *FinallyBlockContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *FinallyBlockContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *FinallyBlockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FinallyBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FinallyBlockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFinallyBlock(s) + } +} + +func (s *FinallyBlockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFinallyBlock(s) + } +} + +func (p *KotlinParser) FinallyBlock() (localctx IFinallyBlockContext) { + this := p + _ = this + + localctx = NewFinallyBlockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, KotlinParserRULE_finallyBlock) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3236) + p.Match(KotlinParserFINALLY) + } + p.SetState(3240) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3237) + p.Match(KotlinParserNL) + } + + p.SetState(3242) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3243) + p.Block() + } + + return localctx +} + +// IJumpExpressionContext is an interface to support dynamic dispatch. +type IJumpExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsJumpExpressionContext differentiates from other interfaces. + IsJumpExpressionContext() +} + +type JumpExpressionContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJumpExpressionContext() *JumpExpressionContext { + var p = new(JumpExpressionContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_jumpExpression + return p +} + +func (*JumpExpressionContext) IsJumpExpressionContext() {} + +func NewJumpExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JumpExpressionContext { + var p = new(JumpExpressionContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_jumpExpression + + return p +} + +func (s *JumpExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *JumpExpressionContext) THROW() antlr.TerminalNode { + return s.GetToken(KotlinParserTHROW, 0) +} + +func (s *JumpExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JumpExpressionContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *JumpExpressionContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *JumpExpressionContext) RETURN() antlr.TerminalNode { + return s.GetToken(KotlinParserRETURN, 0) +} + +func (s *JumpExpressionContext) RETURN_AT() antlr.TerminalNode { + return s.GetToken(KotlinParserRETURN_AT, 0) +} + +func (s *JumpExpressionContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(KotlinParserCONTINUE, 0) +} + +func (s *JumpExpressionContext) CONTINUE_AT() antlr.TerminalNode { + return s.GetToken(KotlinParserCONTINUE_AT, 0) +} + +func (s *JumpExpressionContext) BREAK() antlr.TerminalNode { + return s.GetToken(KotlinParserBREAK, 0) +} + +func (s *JumpExpressionContext) BREAK_AT() antlr.TerminalNode { + return s.GetToken(KotlinParserBREAK_AT, 0) +} + +func (s *JumpExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JumpExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JumpExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterJumpExpression(s) + } +} + +func (s *JumpExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitJumpExpression(s) + } +} + +func (p *KotlinParser) JumpExpression() (localctx IJumpExpressionContext) { + this := p + _ = this + + localctx = NewJumpExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, KotlinParserRULE_jumpExpression) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3261) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserTHROW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3245) + p.Match(KotlinParserTHROW) + } + p.SetState(3249) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3246) + p.Match(KotlinParserNL) + } + + p.SetState(3251) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3252) + p.Expression() + } + + case KotlinParserRETURN_AT, KotlinParserRETURN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3253) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserRETURN_AT || _la == KotlinParserRETURN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3255) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 501, p.GetParserRuleContext()) == 1 { + { + p.SetState(3254) + p.Expression() + } + + } + + case KotlinParserCONTINUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3257) + p.Match(KotlinParserCONTINUE) + } + + case KotlinParserCONTINUE_AT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3258) + p.Match(KotlinParserCONTINUE_AT) + } + + case KotlinParserBREAK: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3259) + p.Match(KotlinParserBREAK) + } + + case KotlinParserBREAK_AT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3260) + p.Match(KotlinParserBREAK_AT) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// ICallableReferenceContext is an interface to support dynamic dispatch. +type ICallableReferenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsCallableReferenceContext differentiates from other interfaces. + IsCallableReferenceContext() +} + +type CallableReferenceContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCallableReferenceContext() *CallableReferenceContext { + var p = new(CallableReferenceContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_callableReference + return p +} + +func (*CallableReferenceContext) IsCallableReferenceContext() {} + +func NewCallableReferenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallableReferenceContext { + var p = new(CallableReferenceContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_callableReference + + return p +} + +func (s *CallableReferenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *CallableReferenceContext) COLONCOLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLONCOLON, 0) +} + +func (s *CallableReferenceContext) SimpleIdentifier() ISimpleIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *CallableReferenceContext) CLASS() antlr.TerminalNode { + return s.GetToken(KotlinParserCLASS, 0) +} + +func (s *CallableReferenceContext) ReceiverType() IReceiverTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReceiverTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReceiverTypeContext) +} + +func (s *CallableReferenceContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *CallableReferenceContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *CallableReferenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CallableReferenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CallableReferenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterCallableReference(s) + } +} + +func (s *CallableReferenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitCallableReference(s) + } +} + +func (p *KotlinParser) CallableReference() (localctx ICallableReferenceContext) { + this := p + _ = this + + localctx = NewCallableReferenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, KotlinParserRULE_callableReference) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(3264) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4611680520869248512) != 0 || (int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-4397231832705) != 0 || (int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&524543) != 0 { + { + p.SetState(3263) + p.ReceiverType() + } + + } + { + p.SetState(3266) + p.Match(KotlinParserCOLONCOLON) + } + p.SetState(3270) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3267) + p.Match(KotlinParserNL) + } + + p.SetState(3272) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + p.SetState(3275) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserFILE, KotlinParserFIELD, KotlinParserPROPERTY, KotlinParserGET, KotlinParserSET, KotlinParserRECEIVER, KotlinParserPARAM, KotlinParserSETPARAM, KotlinParserDELEGATE, KotlinParserIMPORT, KotlinParserCONSTRUCTOR, KotlinParserBY, KotlinParserCOMPANION, KotlinParserINIT, KotlinParserWHERE, KotlinParserCATCH, KotlinParserFINALLY, KotlinParserOUT, KotlinParserDYNAMIC, KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserREIFIED, KotlinParserEXPECT, KotlinParserACTUAL, KotlinParserIdentifier: + { + p.SetState(3273) + p.SimpleIdentifier() + } + + case KotlinParserCLASS: + { + p.SetState(3274) + p.Match(KotlinParserCLASS) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IAssignmentAndOperatorContext is an interface to support dynamic dispatch. +type IAssignmentAndOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAssignmentAndOperatorContext differentiates from other interfaces. + IsAssignmentAndOperatorContext() +} + +type AssignmentAndOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentAndOperatorContext() *AssignmentAndOperatorContext { + var p = new(AssignmentAndOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_assignmentAndOperator + return p +} + +func (*AssignmentAndOperatorContext) IsAssignmentAndOperatorContext() {} + +func NewAssignmentAndOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentAndOperatorContext { + var p = new(AssignmentAndOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_assignmentAndOperator + + return p +} + +func (s *AssignmentAndOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentAndOperatorContext) ADD_ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserADD_ASSIGNMENT, 0) +} + +func (s *AssignmentAndOperatorContext) SUB_ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserSUB_ASSIGNMENT, 0) +} + +func (s *AssignmentAndOperatorContext) MULT_ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserMULT_ASSIGNMENT, 0) +} + +func (s *AssignmentAndOperatorContext) DIV_ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserDIV_ASSIGNMENT, 0) +} + +func (s *AssignmentAndOperatorContext) MOD_ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(KotlinParserMOD_ASSIGNMENT, 0) +} + +func (s *AssignmentAndOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentAndOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentAndOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAssignmentAndOperator(s) + } +} + +func (s *AssignmentAndOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAssignmentAndOperator(s) + } +} + +func (p *KotlinParser) AssignmentAndOperator() (localctx IAssignmentAndOperatorContext) { + this := p + _ = this + + localctx = NewAssignmentAndOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, KotlinParserRULE_assignmentAndOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3277) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16642998272) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IEqualityOperatorContext is an interface to support dynamic dispatch. +type IEqualityOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsEqualityOperatorContext differentiates from other interfaces. + IsEqualityOperatorContext() +} + +type EqualityOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEqualityOperatorContext() *EqualityOperatorContext { + var p = new(EqualityOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_equalityOperator + return p +} + +func (*EqualityOperatorContext) IsEqualityOperatorContext() {} + +func NewEqualityOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityOperatorContext { + var p = new(EqualityOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_equalityOperator + + return p +} + +func (s *EqualityOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *EqualityOperatorContext) EXCL_EQ() antlr.TerminalNode { + return s.GetToken(KotlinParserEXCL_EQ, 0) +} + +func (s *EqualityOperatorContext) EXCL_EQEQ() antlr.TerminalNode { + return s.GetToken(KotlinParserEXCL_EQEQ, 0) +} + +func (s *EqualityOperatorContext) EQEQ() antlr.TerminalNode { + return s.GetToken(KotlinParserEQEQ, 0) +} + +func (s *EqualityOperatorContext) EQEQEQ() antlr.TerminalNode { + return s.GetToken(KotlinParserEQEQEQ, 0) +} + +func (s *EqualityOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EqualityOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EqualityOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterEqualityOperator(s) + } +} + +func (s *EqualityOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitEqualityOperator(s) + } +} + +func (p *KotlinParser) EqualityOperator() (localctx IEqualityOperatorContext) { + this := p + _ = this + + localctx = NewEqualityOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, KotlinParserRULE_equalityOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3279) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&30399297484750848) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IComparisonOperatorContext is an interface to support dynamic dispatch. +type IComparisonOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsComparisonOperatorContext differentiates from other interfaces. + IsComparisonOperatorContext() +} + +type ComparisonOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext { + var p = new(ComparisonOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_comparisonOperator + return p +} + +func (*ComparisonOperatorContext) IsComparisonOperatorContext() {} + +func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext { + var p = new(ComparisonOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_comparisonOperator + + return p +} + +func (s *ComparisonOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *ComparisonOperatorContext) LANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserLANGLE, 0) +} + +func (s *ComparisonOperatorContext) RANGLE() antlr.TerminalNode { + return s.GetToken(KotlinParserRANGLE, 0) +} + +func (s *ComparisonOperatorContext) LE() antlr.TerminalNode { + return s.GetToken(KotlinParserLE, 0) +} + +func (s *ComparisonOperatorContext) GE() antlr.TerminalNode { + return s.GetToken(KotlinParserGE, 0) +} + +func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterComparisonOperator(s) + } +} + +func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitComparisonOperator(s) + } +} + +func (p *KotlinParser) ComparisonOperator() (localctx IComparisonOperatorContext) { + this := p + _ = this + + localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, KotlinParserRULE_comparisonOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3281) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&1055531162664960) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IInOperatorContext is an interface to support dynamic dispatch. +type IInOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsInOperatorContext differentiates from other interfaces. + IsInOperatorContext() +} + +type InOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInOperatorContext() *InOperatorContext { + var p = new(InOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_inOperator + return p +} + +func (*InOperatorContext) IsInOperatorContext() {} + +func NewInOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InOperatorContext { + var p = new(InOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_inOperator + + return p +} + +func (s *InOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *InOperatorContext) IN() antlr.TerminalNode { + return s.GetToken(KotlinParserIN, 0) +} + +func (s *InOperatorContext) NOT_IN() antlr.TerminalNode { + return s.GetToken(KotlinParserNOT_IN, 0) +} + +func (s *InOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterInOperator(s) + } +} + +func (s *InOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitInOperator(s) + } +} + +func (p *KotlinParser) InOperator() (localctx IInOperatorContext) { + this := p + _ = this + + localctx = NewInOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, KotlinParserRULE_inOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3283) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserIN || _la == KotlinParserNOT_IN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IIsOperatorContext is an interface to support dynamic dispatch. +type IIsOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsIsOperatorContext differentiates from other interfaces. + IsIsOperatorContext() +} + +type IsOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIsOperatorContext() *IsOperatorContext { + var p = new(IsOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_isOperator + return p +} + +func (*IsOperatorContext) IsIsOperatorContext() {} + +func NewIsOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IsOperatorContext { + var p = new(IsOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_isOperator + + return p +} + +func (s *IsOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *IsOperatorContext) IS() antlr.TerminalNode { + return s.GetToken(KotlinParserIS, 0) +} + +func (s *IsOperatorContext) NOT_IS() antlr.TerminalNode { + return s.GetToken(KotlinParserNOT_IS, 0) +} + +func (s *IsOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IsOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IsOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterIsOperator(s) + } +} + +func (s *IsOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitIsOperator(s) + } +} + +func (p *KotlinParser) IsOperator() (localctx IIsOperatorContext) { + this := p + _ = this + + localctx = NewIsOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, KotlinParserRULE_isOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3285) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserIS || _la == KotlinParserNOT_IS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IAdditiveOperatorContext is an interface to support dynamic dispatch. +type IAdditiveOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAdditiveOperatorContext differentiates from other interfaces. + IsAdditiveOperatorContext() +} + +type AdditiveOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdditiveOperatorContext() *AdditiveOperatorContext { + var p = new(AdditiveOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_additiveOperator + return p +} + +func (*AdditiveOperatorContext) IsAdditiveOperatorContext() {} + +func NewAdditiveOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveOperatorContext { + var p = new(AdditiveOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_additiveOperator + + return p +} + +func (s *AdditiveOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *AdditiveOperatorContext) ADD() antlr.TerminalNode { + return s.GetToken(KotlinParserADD, 0) +} + +func (s *AdditiveOperatorContext) SUB() antlr.TerminalNode { + return s.GetToken(KotlinParserSUB, 0) +} + +func (s *AdditiveOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdditiveOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AdditiveOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAdditiveOperator(s) + } +} + +func (s *AdditiveOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAdditiveOperator(s) + } +} + +func (p *KotlinParser) AdditiveOperator() (localctx IAdditiveOperatorContext) { + this := p + _ = this + + localctx = NewAdditiveOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, KotlinParserRULE_additiveOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3287) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserADD || _la == KotlinParserSUB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IMultiplicativeOperatorContext is an interface to support dynamic dispatch. +type IMultiplicativeOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiplicativeOperatorContext differentiates from other interfaces. + IsMultiplicativeOperatorContext() +} + +type MultiplicativeOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiplicativeOperatorContext() *MultiplicativeOperatorContext { + var p = new(MultiplicativeOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiplicativeOperator + return p +} + +func (*MultiplicativeOperatorContext) IsMultiplicativeOperatorContext() {} + +func NewMultiplicativeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeOperatorContext { + var p = new(MultiplicativeOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiplicativeOperator + + return p +} + +func (s *MultiplicativeOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiplicativeOperatorContext) MULT() antlr.TerminalNode { + return s.GetToken(KotlinParserMULT, 0) +} + +func (s *MultiplicativeOperatorContext) DIV() antlr.TerminalNode { + return s.GetToken(KotlinParserDIV, 0) +} + +func (s *MultiplicativeOperatorContext) MOD() antlr.TerminalNode { + return s.GetToken(KotlinParserMOD, 0) +} + +func (s *MultiplicativeOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiplicativeOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiplicativeOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiplicativeOperator(s) + } +} + +func (s *MultiplicativeOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiplicativeOperator(s) + } +} + +func (p *KotlinParser) MultiplicativeOperator() (localctx IMultiplicativeOperatorContext) { + this := p + _ = this + + localctx = NewMultiplicativeOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, KotlinParserRULE_multiplicativeOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3289) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&229376) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IAsOperatorContext is an interface to support dynamic dispatch. +type IAsOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAsOperatorContext differentiates from other interfaces. + IsAsOperatorContext() +} + +type AsOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsOperatorContext() *AsOperatorContext { + var p = new(AsOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_asOperator + return p +} + +func (*AsOperatorContext) IsAsOperatorContext() {} + +func NewAsOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsOperatorContext { + var p = new(AsOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_asOperator + + return p +} + +func (s *AsOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *AsOperatorContext) AS() antlr.TerminalNode { + return s.GetToken(KotlinParserAS, 0) +} + +func (s *AsOperatorContext) AS_SAFE() antlr.TerminalNode { + return s.GetToken(KotlinParserAS_SAFE, 0) +} + +func (s *AsOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AsOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AsOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAsOperator(s) + } +} + +func (s *AsOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAsOperator(s) + } +} + +func (p *KotlinParser) AsOperator() (localctx IAsOperatorContext) { + this := p + _ = this + + localctx = NewAsOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, KotlinParserRULE_asOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3291) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserAS_SAFE || _la == KotlinParserAS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IPrefixUnaryOperatorContext is an interface to support dynamic dispatch. +type IPrefixUnaryOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPrefixUnaryOperatorContext differentiates from other interfaces. + IsPrefixUnaryOperatorContext() +} + +type PrefixUnaryOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrefixUnaryOperatorContext() *PrefixUnaryOperatorContext { + var p = new(PrefixUnaryOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_prefixUnaryOperator + return p +} + +func (*PrefixUnaryOperatorContext) IsPrefixUnaryOperatorContext() {} + +func NewPrefixUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrefixUnaryOperatorContext { + var p = new(PrefixUnaryOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_prefixUnaryOperator + + return p +} + +func (s *PrefixUnaryOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrefixUnaryOperatorContext) INCR() antlr.TerminalNode { + return s.GetToken(KotlinParserINCR, 0) +} + +func (s *PrefixUnaryOperatorContext) DECR() antlr.TerminalNode { + return s.GetToken(KotlinParserDECR, 0) +} + +func (s *PrefixUnaryOperatorContext) SUB() antlr.TerminalNode { + return s.GetToken(KotlinParserSUB, 0) +} + +func (s *PrefixUnaryOperatorContext) ADD() antlr.TerminalNode { + return s.GetToken(KotlinParserADD, 0) +} + +func (s *PrefixUnaryOperatorContext) Excl() IExclContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExclContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExclContext) +} + +func (s *PrefixUnaryOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrefixUnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrefixUnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPrefixUnaryOperator(s) + } +} + +func (s *PrefixUnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPrefixUnaryOperator(s) + } +} + +func (p *KotlinParser) PrefixUnaryOperator() (localctx IPrefixUnaryOperatorContext) { + this := p + _ = this + + localctx = NewPrefixUnaryOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, KotlinParserRULE_prefixUnaryOperator) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3298) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserINCR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3293) + p.Match(KotlinParserINCR) + } + + case KotlinParserDECR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3294) + p.Match(KotlinParserDECR) + } + + case KotlinParserSUB: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3295) + p.Match(KotlinParserSUB) + } + + case KotlinParserADD: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3296) + p.Match(KotlinParserADD) + } + + case KotlinParserEXCL_WS, KotlinParserEXCL_NO_WS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3297) + p.Excl() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IPostfixUnaryOperatorContext is an interface to support dynamic dispatch. +type IPostfixUnaryOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPostfixUnaryOperatorContext differentiates from other interfaces. + IsPostfixUnaryOperatorContext() +} + +type PostfixUnaryOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPostfixUnaryOperatorContext() *PostfixUnaryOperatorContext { + var p = new(PostfixUnaryOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_postfixUnaryOperator + return p +} + +func (*PostfixUnaryOperatorContext) IsPostfixUnaryOperatorContext() {} + +func NewPostfixUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostfixUnaryOperatorContext { + var p = new(PostfixUnaryOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_postfixUnaryOperator + + return p +} + +func (s *PostfixUnaryOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *PostfixUnaryOperatorContext) INCR() antlr.TerminalNode { + return s.GetToken(KotlinParserINCR, 0) +} + +func (s *PostfixUnaryOperatorContext) DECR() antlr.TerminalNode { + return s.GetToken(KotlinParserDECR, 0) +} + +func (s *PostfixUnaryOperatorContext) EXCL_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserEXCL_NO_WS, 0) +} + +func (s *PostfixUnaryOperatorContext) Excl() IExclContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExclContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExclContext) +} + +func (s *PostfixUnaryOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PostfixUnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PostfixUnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPostfixUnaryOperator(s) + } +} + +func (s *PostfixUnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPostfixUnaryOperator(s) + } +} + +func (p *KotlinParser) PostfixUnaryOperator() (localctx IPostfixUnaryOperatorContext) { + this := p + _ = this + + localctx = NewPostfixUnaryOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, KotlinParserRULE_postfixUnaryOperator) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3304) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserINCR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3300) + p.Match(KotlinParserINCR) + } + + case KotlinParserDECR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3301) + p.Match(KotlinParserDECR) + } + + case KotlinParserEXCL_NO_WS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3302) + p.Match(KotlinParserEXCL_NO_WS) + } + { + p.SetState(3303) + p.Excl() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IExclContext is an interface to support dynamic dispatch. +type IExclContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsExclContext differentiates from other interfaces. + IsExclContext() +} + +type ExclContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExclContext() *ExclContext { + var p = new(ExclContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_excl + return p +} + +func (*ExclContext) IsExclContext() {} + +func NewExclContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclContext { + var p = new(ExclContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_excl + + return p +} + +func (s *ExclContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExclContext) EXCL_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserEXCL_NO_WS, 0) +} + +func (s *ExclContext) EXCL_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserEXCL_WS, 0) +} + +func (s *ExclContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExclContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExclContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterExcl(s) + } +} + +func (s *ExclContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitExcl(s) + } +} + +func (p *KotlinParser) Excl() (localctx IExclContext) { + this := p + _ = this + + localctx = NewExclContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, KotlinParserRULE_excl) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3306) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserEXCL_WS || _la == KotlinParserEXCL_NO_WS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IMemberAccessOperatorContext is an interface to support dynamic dispatch. +type IMemberAccessOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMemberAccessOperatorContext differentiates from other interfaces. + IsMemberAccessOperatorContext() +} + +type MemberAccessOperatorContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMemberAccessOperatorContext() *MemberAccessOperatorContext { + var p = new(MemberAccessOperatorContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_memberAccessOperator + return p +} + +func (*MemberAccessOperatorContext) IsMemberAccessOperatorContext() {} + +func NewMemberAccessOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberAccessOperatorContext { + var p = new(MemberAccessOperatorContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_memberAccessOperator + + return p +} + +func (s *MemberAccessOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *MemberAccessOperatorContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *MemberAccessOperatorContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *MemberAccessOperatorContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *MemberAccessOperatorContext) SafeNav() ISafeNavContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISafeNavContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISafeNavContext) +} + +func (s *MemberAccessOperatorContext) COLONCOLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLONCOLON, 0) +} + +func (s *MemberAccessOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MemberAccessOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MemberAccessOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMemberAccessOperator(s) + } +} + +func (s *MemberAccessOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMemberAccessOperator(s) + } +} + +func (p *KotlinParser) MemberAccessOperator() (localctx IMemberAccessOperatorContext) { + this := p + _ = this + + localctx = NewMemberAccessOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, KotlinParserRULE_memberAccessOperator) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3323) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 510, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(3311) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3308) + p.Match(KotlinParserNL) + } + + p.SetState(3313) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3314) + p.Match(KotlinParserDOT) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(3318) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3315) + p.Match(KotlinParserNL) + } + + p.SetState(3320) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3321) + p.SafeNav() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3322) + p.Match(KotlinParserCOLONCOLON) + } + + } + + return localctx +} + +// ISafeNavContext is an interface to support dynamic dispatch. +type ISafeNavContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSafeNavContext differentiates from other interfaces. + IsSafeNavContext() +} + +type SafeNavContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySafeNavContext() *SafeNavContext { + var p = new(SafeNavContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_safeNav + return p +} + +func (*SafeNavContext) IsSafeNavContext() {} + +func NewSafeNavContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SafeNavContext { + var p = new(SafeNavContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_safeNav + + return p +} + +func (s *SafeNavContext) GetParser() antlr.Parser { return s.parser } + +func (s *SafeNavContext) QUEST_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserQUEST_NO_WS, 0) +} + +func (s *SafeNavContext) DOT() antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, 0) +} + +func (s *SafeNavContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SafeNavContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SafeNavContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSafeNav(s) + } +} + +func (s *SafeNavContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSafeNav(s) + } +} + +func (p *KotlinParser) SafeNav() (localctx ISafeNavContext) { + this := p + _ = this + + localctx = NewSafeNavContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, KotlinParserRULE_safeNav) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3325) + p.Match(KotlinParserQUEST_NO_WS) + } + { + p.SetState(3326) + p.Match(KotlinParserDOT) + } + + return localctx +} + +// IModifiersContext is an interface to support dynamic dispatch. +type IModifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsModifiersContext differentiates from other interfaces. + IsModifiersContext() +} + +type ModifiersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModifiersContext() *ModifiersContext { + var p = new(ModifiersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_modifiers + return p +} + +func (*ModifiersContext) IsModifiersContext() {} + +func NewModifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModifiersContext { + var p = new(ModifiersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_modifiers + + return p +} + +func (s *ModifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *ModifiersContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *ModifiersContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *ModifiersContext) AllModifier() []IModifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModifierContext); ok { + len++ + } + } + + tst := make([]IModifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModifierContext); ok { + tst[i] = t.(IModifierContext) + i++ + } + } + + return tst +} + +func (s *ModifiersContext) Modifier(i int) IModifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModifierContext) +} + +func (s *ModifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ModifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterModifiers(s) + } +} + +func (s *ModifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitModifiers(s) + } +} + +func (p *KotlinParser) Modifiers() (localctx IModifiersContext) { + this := p + _ = this + + localctx = NewModifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, KotlinParserRULE_modifiers) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3330) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3330) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + { + p.SetState(3328) + p.Annotation() + } + + case KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL, KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE, KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND, KotlinParserOVERRIDE, KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN, KotlinParserCONST, KotlinParserLATEINIT, KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE, KotlinParserEXPECT, KotlinParserACTUAL: + { + p.SetState(3329) + p.Modifier() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(3332) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 512, p.GetParserRuleContext()) + } + + return localctx +} + +// IParameterModifiersContext is an interface to support dynamic dispatch. +type IParameterModifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParameterModifiersContext differentiates from other interfaces. + IsParameterModifiersContext() +} + +type ParameterModifiersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterModifiersContext() *ParameterModifiersContext { + var p = new(ParameterModifiersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parameterModifiers + return p +} + +func (*ParameterModifiersContext) IsParameterModifiersContext() {} + +func NewParameterModifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterModifiersContext { + var p = new(ParameterModifiersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parameterModifiers + + return p +} + +func (s *ParameterModifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterModifiersContext) AllAnnotation() []IAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotationContext); ok { + len++ + } + } + + tst := make([]IAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotationContext); ok { + tst[i] = t.(IAnnotationContext) + i++ + } + } + + return tst +} + +func (s *ParameterModifiersContext) Annotation(i int) IAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *ParameterModifiersContext) AllParameterModifier() []IParameterModifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterModifierContext); ok { + len++ + } + } + + tst := make([]IParameterModifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterModifierContext); ok { + tst[i] = t.(IParameterModifierContext) + i++ + } + } + + return tst +} + +func (s *ParameterModifiersContext) ParameterModifier(i int) IParameterModifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterModifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterModifierContext) +} + +func (s *ParameterModifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterModifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterModifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParameterModifiers(s) + } +} + +func (s *ParameterModifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParameterModifiers(s) + } +} + +func (p *KotlinParser) ParameterModifiers() (localctx IParameterModifiersContext) { + this := p + _ = this + + localctx = NewParameterModifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, KotlinParserRULE_parameterModifiers) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3336) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3336) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + { + p.SetState(3334) + p.Annotation() + } + + case KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE: + { + p.SetState(3335) + p.ParameterModifier() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(3338) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 514, p.GetParserRuleContext()) + } + + return localctx +} + +// IModifierContext is an interface to support dynamic dispatch. +type IModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsModifierContext differentiates from other interfaces. + IsModifierContext() +} + +type ModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModifierContext() *ModifierContext { + var p = new(ModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_modifier + return p +} + +func (*ModifierContext) IsModifierContext() {} + +func NewModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModifierContext { + var p = new(ModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_modifier + + return p +} + +func (s *ModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *ModifierContext) ClassModifier() IClassModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClassModifierContext) +} + +func (s *ModifierContext) MemberModifier() IMemberModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMemberModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMemberModifierContext) +} + +func (s *ModifierContext) VisibilityModifier() IVisibilityModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVisibilityModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVisibilityModifierContext) +} + +func (s *ModifierContext) FunctionModifier() IFunctionModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionModifierContext) +} + +func (s *ModifierContext) PropertyModifier() IPropertyModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyModifierContext) +} + +func (s *ModifierContext) InheritanceModifier() IInheritanceModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInheritanceModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInheritanceModifierContext) +} + +func (s *ModifierContext) ParameterModifier() IParameterModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterModifierContext) +} + +func (s *ModifierContext) PlatformModifier() IPlatformModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlatformModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlatformModifierContext) +} + +func (s *ModifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *ModifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *ModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterModifier(s) + } +} + +func (s *ModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitModifier(s) + } +} + +func (p *KotlinParser) Modifier() (localctx IModifierContext) { + this := p + _ = this + + localctx = NewModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, KotlinParserRULE_modifier) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3348) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserENUM, KotlinParserSEALED, KotlinParserANNOTATION, KotlinParserDATA, KotlinParserINNER, KotlinParserVALUE: + { + p.SetState(3340) + p.ClassModifier() + } + + case KotlinParserOVERRIDE, KotlinParserLATEINIT: + { + p.SetState(3341) + p.MemberModifier() + } + + case KotlinParserPUBLIC, KotlinParserPRIVATE, KotlinParserPROTECTED, KotlinParserINTERNAL: + { + p.SetState(3342) + p.VisibilityModifier() + } + + case KotlinParserTAILREC, KotlinParserOPERATOR, KotlinParserINLINE, KotlinParserINFIX, KotlinParserEXTERNAL, KotlinParserSUSPEND: + { + p.SetState(3343) + p.FunctionModifier() + } + + case KotlinParserCONST: + { + p.SetState(3344) + p.PropertyModifier() + } + + case KotlinParserABSTRACT, KotlinParserFINAL, KotlinParserOPEN: + { + p.SetState(3345) + p.InheritanceModifier() + } + + case KotlinParserVARARG, KotlinParserNOINLINE, KotlinParserCROSSINLINE: + { + p.SetState(3346) + p.ParameterModifier() + } + + case KotlinParserEXPECT, KotlinParserACTUAL: + { + p.SetState(3347) + p.PlatformModifier() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + p.SetState(3353) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 516, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3350) + p.Match(KotlinParserNL) + } + + } + p.SetState(3355) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 516, p.GetParserRuleContext()) + } + + return localctx +} + +// ITypeModifiersContext is an interface to support dynamic dispatch. +type ITypeModifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeModifiersContext differentiates from other interfaces. + IsTypeModifiersContext() +} + +type TypeModifiersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeModifiersContext() *TypeModifiersContext { + var p = new(TypeModifiersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeModifiers + return p +} + +func (*TypeModifiersContext) IsTypeModifiersContext() {} + +func NewTypeModifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeModifiersContext { + var p = new(TypeModifiersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeModifiers + + return p +} + +func (s *TypeModifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeModifiersContext) AllTypeModifier() []ITypeModifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeModifierContext); ok { + len++ + } + } + + tst := make([]ITypeModifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeModifierContext); ok { + tst[i] = t.(ITypeModifierContext) + i++ + } + } + + return tst +} + +func (s *TypeModifiersContext) TypeModifier(i int) ITypeModifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeModifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeModifierContext) +} + +func (s *TypeModifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeModifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeModifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeModifiers(s) + } +} + +func (s *TypeModifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeModifiers(s) + } +} + +func (p *KotlinParser) TypeModifiers() (localctx ITypeModifiersContext) { + this := p + _ = this + + localctx = NewTypeModifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, KotlinParserRULE_typeModifiers) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3357) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(3356) + p.TypeModifier() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(3359) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 517, p.GetParserRuleContext()) + } + + return localctx +} + +// ITypeModifierContext is an interface to support dynamic dispatch. +type ITypeModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeModifierContext differentiates from other interfaces. + IsTypeModifierContext() +} + +type TypeModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeModifierContext() *TypeModifierContext { + var p = new(TypeModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeModifier + return p +} + +func (*TypeModifierContext) IsTypeModifierContext() {} + +func NewTypeModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeModifierContext { + var p = new(TypeModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeModifier + + return p +} + +func (s *TypeModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeModifierContext) Annotation() IAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *TypeModifierContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(KotlinParserSUSPEND, 0) +} + +func (s *TypeModifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeModifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeModifier(s) + } +} + +func (s *TypeModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeModifier(s) + } +} + +func (p *KotlinParser) TypeModifier() (localctx ITypeModifierContext) { + this := p + _ = this + + localctx = NewTypeModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, KotlinParserRULE_typeModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3369) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3361) + p.Annotation() + } + + case KotlinParserSUSPEND: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3362) + p.Match(KotlinParserSUSPEND) + } + p.SetState(3366) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3363) + p.Match(KotlinParserNL) + } + + p.SetState(3368) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IClassModifierContext is an interface to support dynamic dispatch. +type IClassModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsClassModifierContext differentiates from other interfaces. + IsClassModifierContext() +} + +type ClassModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassModifierContext() *ClassModifierContext { + var p = new(ClassModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_classModifier + return p +} + +func (*ClassModifierContext) IsClassModifierContext() {} + +func NewClassModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassModifierContext { + var p = new(ClassModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_classModifier + + return p +} + +func (s *ClassModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClassModifierContext) ENUM() antlr.TerminalNode { + return s.GetToken(KotlinParserENUM, 0) +} + +func (s *ClassModifierContext) SEALED() antlr.TerminalNode { + return s.GetToken(KotlinParserSEALED, 0) +} + +func (s *ClassModifierContext) ANNOTATION() antlr.TerminalNode { + return s.GetToken(KotlinParserANNOTATION, 0) +} + +func (s *ClassModifierContext) DATA() antlr.TerminalNode { + return s.GetToken(KotlinParserDATA, 0) +} + +func (s *ClassModifierContext) INNER() antlr.TerminalNode { + return s.GetToken(KotlinParserINNER, 0) +} + +func (s *ClassModifierContext) VALUE() antlr.TerminalNode { + return s.GetToken(KotlinParserVALUE, 0) +} + +func (s *ClassModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClassModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClassModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterClassModifier(s) + } +} + +func (s *ClassModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitClassModifier(s) + } +} + +func (p *KotlinParser) ClassModifier() (localctx IClassModifierContext) { + this := p + _ = this + + localctx = NewClassModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, KotlinParserRULE_classModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3371) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-112)) & ^0x3f) == 0 && ((int64(1)<<(_la-112))&63) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IMemberModifierContext is an interface to support dynamic dispatch. +type IMemberModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMemberModifierContext differentiates from other interfaces. + IsMemberModifierContext() +} + +type MemberModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMemberModifierContext() *MemberModifierContext { + var p = new(MemberModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_memberModifier + return p +} + +func (*MemberModifierContext) IsMemberModifierContext() {} + +func NewMemberModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberModifierContext { + var p = new(MemberModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_memberModifier + + return p +} + +func (s *MemberModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *MemberModifierContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(KotlinParserOVERRIDE, 0) +} + +func (s *MemberModifierContext) LATEINIT() antlr.TerminalNode { + return s.GetToken(KotlinParserLATEINIT, 0) +} + +func (s *MemberModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MemberModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MemberModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMemberModifier(s) + } +} + +func (s *MemberModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMemberModifier(s) + } +} + +func (p *KotlinParser) MemberModifier() (localctx IMemberModifierContext) { + this := p + _ = this + + localctx = NewMemberModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, KotlinParserRULE_memberModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3373) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserOVERRIDE || _la == KotlinParserLATEINIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IVisibilityModifierContext is an interface to support dynamic dispatch. +type IVisibilityModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsVisibilityModifierContext differentiates from other interfaces. + IsVisibilityModifierContext() +} + +type VisibilityModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVisibilityModifierContext() *VisibilityModifierContext { + var p = new(VisibilityModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_visibilityModifier + return p +} + +func (*VisibilityModifierContext) IsVisibilityModifierContext() {} + +func NewVisibilityModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VisibilityModifierContext { + var p = new(VisibilityModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_visibilityModifier + + return p +} + +func (s *VisibilityModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *VisibilityModifierContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(KotlinParserPUBLIC, 0) +} + +func (s *VisibilityModifierContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(KotlinParserPRIVATE, 0) +} + +func (s *VisibilityModifierContext) INTERNAL() antlr.TerminalNode { + return s.GetToken(KotlinParserINTERNAL, 0) +} + +func (s *VisibilityModifierContext) PROTECTED() antlr.TerminalNode { + return s.GetToken(KotlinParserPROTECTED, 0) +} + +func (s *VisibilityModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VisibilityModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VisibilityModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterVisibilityModifier(s) + } +} + +func (s *VisibilityModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitVisibilityModifier(s) + } +} + +func (p *KotlinParser) VisibilityModifier() (localctx IVisibilityModifierContext) { + this := p + _ = this + + localctx = NewVisibilityModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, KotlinParserRULE_visibilityModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3375) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-108)) & ^0x3f) == 0 && ((int64(1)<<(_la-108))&15) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IVarianceModifierContext is an interface to support dynamic dispatch. +type IVarianceModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsVarianceModifierContext differentiates from other interfaces. + IsVarianceModifierContext() +} + +type VarianceModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarianceModifierContext() *VarianceModifierContext { + var p = new(VarianceModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_varianceModifier + return p +} + +func (*VarianceModifierContext) IsVarianceModifierContext() {} + +func NewVarianceModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VarianceModifierContext { + var p = new(VarianceModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_varianceModifier + + return p +} + +func (s *VarianceModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *VarianceModifierContext) IN() antlr.TerminalNode { + return s.GetToken(KotlinParserIN, 0) +} + +func (s *VarianceModifierContext) OUT() antlr.TerminalNode { + return s.GetToken(KotlinParserOUT, 0) +} + +func (s *VarianceModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VarianceModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VarianceModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterVarianceModifier(s) + } +} + +func (s *VarianceModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitVarianceModifier(s) + } +} + +func (p *KotlinParser) VarianceModifier() (localctx IVarianceModifierContext) { + this := p + _ = this + + localctx = NewVarianceModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, KotlinParserRULE_varianceModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3377) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserIN || _la == KotlinParserOUT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// ITypeParameterModifiersContext is an interface to support dynamic dispatch. +type ITypeParameterModifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeParameterModifiersContext differentiates from other interfaces. + IsTypeParameterModifiersContext() +} + +type TypeParameterModifiersContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeParameterModifiersContext() *TypeParameterModifiersContext { + var p = new(TypeParameterModifiersContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeParameterModifiers + return p +} + +func (*TypeParameterModifiersContext) IsTypeParameterModifiersContext() {} + +func NewTypeParameterModifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParameterModifiersContext { + var p = new(TypeParameterModifiersContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeParameterModifiers + + return p +} + +func (s *TypeParameterModifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeParameterModifiersContext) AllTypeParameterModifier() []ITypeParameterModifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeParameterModifierContext); ok { + len++ + } + } + + tst := make([]ITypeParameterModifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeParameterModifierContext); ok { + tst[i] = t.(ITypeParameterModifierContext) + i++ + } + } + + return tst +} + +func (s *TypeParameterModifiersContext) TypeParameterModifier(i int) ITypeParameterModifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeParameterModifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeParameterModifierContext) +} + +func (s *TypeParameterModifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeParameterModifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeParameterModifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeParameterModifiers(s) + } +} + +func (s *TypeParameterModifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeParameterModifiers(s) + } +} + +func (p *KotlinParser) TypeParameterModifiers() (localctx ITypeParameterModifiersContext) { + this := p + _ = this + + localctx = NewTypeParameterModifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, KotlinParserRULE_typeParameterModifiers) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3380) + p.GetErrorHandler().Sync(p) + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(3379) + p.TypeParameterModifier() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + p.SetState(3382) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 520, p.GetParserRuleContext()) + } + + return localctx +} + +// ITypeParameterModifierContext is an interface to support dynamic dispatch. +type ITypeParameterModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsTypeParameterModifierContext differentiates from other interfaces. + IsTypeParameterModifierContext() +} + +type TypeParameterModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeParameterModifierContext() *TypeParameterModifierContext { + var p = new(TypeParameterModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_typeParameterModifier + return p +} + +func (*TypeParameterModifierContext) IsTypeParameterModifierContext() {} + +func NewTypeParameterModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParameterModifierContext { + var p = new(TypeParameterModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_typeParameterModifier + + return p +} + +func (s *TypeParameterModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeParameterModifierContext) ReificationModifier() IReificationModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReificationModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReificationModifierContext) +} + +func (s *TypeParameterModifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *TypeParameterModifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *TypeParameterModifierContext) VarianceModifier() IVarianceModifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarianceModifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarianceModifierContext) +} + +func (s *TypeParameterModifierContext) Annotation() IAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *TypeParameterModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeParameterModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeParameterModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterTypeParameterModifier(s) + } +} + +func (s *TypeParameterModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitTypeParameterModifier(s) + } +} + +func (p *KotlinParser) TypeParameterModifier() (localctx ITypeParameterModifierContext) { + this := p + _ = this + + localctx = NewTypeParameterModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, KotlinParserRULE_typeParameterModifier) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.SetState(3399) + p.GetErrorHandler().Sync(p) + + switch p.GetTokenStream().LA(1) { + case KotlinParserREIFIED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3384) + p.ReificationModifier() + } + p.SetState(3388) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 521, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3385) + p.Match(KotlinParserNL) + } + + } + p.SetState(3390) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 521, p.GetParserRuleContext()) + } + + case KotlinParserIN, KotlinParserOUT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3391) + p.VarianceModifier() + } + p.SetState(3395) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 522, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3392) + p.Match(KotlinParserNL) + } + + } + p.SetState(3397) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 522, p.GetParserRuleContext()) + } + + case KotlinParserAT_NO_WS, KotlinParserAT_PRE_WS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3398) + p.Annotation() + } + + default: + panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + } + + return localctx +} + +// IFunctionModifierContext is an interface to support dynamic dispatch. +type IFunctionModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsFunctionModifierContext differentiates from other interfaces. + IsFunctionModifierContext() +} + +type FunctionModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionModifierContext() *FunctionModifierContext { + var p = new(FunctionModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_functionModifier + return p +} + +func (*FunctionModifierContext) IsFunctionModifierContext() {} + +func NewFunctionModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionModifierContext { + var p = new(FunctionModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_functionModifier + + return p +} + +func (s *FunctionModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionModifierContext) TAILREC() antlr.TerminalNode { + return s.GetToken(KotlinParserTAILREC, 0) +} + +func (s *FunctionModifierContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(KotlinParserOPERATOR, 0) +} + +func (s *FunctionModifierContext) INFIX() antlr.TerminalNode { + return s.GetToken(KotlinParserINFIX, 0) +} + +func (s *FunctionModifierContext) INLINE() antlr.TerminalNode { + return s.GetToken(KotlinParserINLINE, 0) +} + +func (s *FunctionModifierContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(KotlinParserEXTERNAL, 0) +} + +func (s *FunctionModifierContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(KotlinParserSUSPEND, 0) +} + +func (s *FunctionModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterFunctionModifier(s) + } +} + +func (s *FunctionModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitFunctionModifier(s) + } +} + +func (p *KotlinParser) FunctionModifier() (localctx IFunctionModifierContext) { + this := p + _ = this + + localctx = NewFunctionModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, KotlinParserRULE_functionModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3401) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&63) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IPropertyModifierContext is an interface to support dynamic dispatch. +type IPropertyModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPropertyModifierContext differentiates from other interfaces. + IsPropertyModifierContext() +} + +type PropertyModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPropertyModifierContext() *PropertyModifierContext { + var p = new(PropertyModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_propertyModifier + return p +} + +func (*PropertyModifierContext) IsPropertyModifierContext() {} + +func NewPropertyModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyModifierContext { + var p = new(PropertyModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_propertyModifier + + return p +} + +func (s *PropertyModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyModifierContext) CONST() antlr.TerminalNode { + return s.GetToken(KotlinParserCONST, 0) +} + +func (s *PropertyModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPropertyModifier(s) + } +} + +func (s *PropertyModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPropertyModifier(s) + } +} + +func (p *KotlinParser) PropertyModifier() (localctx IPropertyModifierContext) { + this := p + _ = this + + localctx = NewPropertyModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, KotlinParserRULE_propertyModifier) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3403) + p.Match(KotlinParserCONST) + } + + return localctx +} + +// IInheritanceModifierContext is an interface to support dynamic dispatch. +type IInheritanceModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsInheritanceModifierContext differentiates from other interfaces. + IsInheritanceModifierContext() +} + +type InheritanceModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInheritanceModifierContext() *InheritanceModifierContext { + var p = new(InheritanceModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_inheritanceModifier + return p +} + +func (*InheritanceModifierContext) IsInheritanceModifierContext() {} + +func NewInheritanceModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InheritanceModifierContext { + var p = new(InheritanceModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_inheritanceModifier + + return p +} + +func (s *InheritanceModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *InheritanceModifierContext) ABSTRACT() antlr.TerminalNode { + return s.GetToken(KotlinParserABSTRACT, 0) +} + +func (s *InheritanceModifierContext) FINAL() antlr.TerminalNode { + return s.GetToken(KotlinParserFINAL, 0) +} + +func (s *InheritanceModifierContext) OPEN() antlr.TerminalNode { + return s.GetToken(KotlinParserOPEN, 0) +} + +func (s *InheritanceModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InheritanceModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InheritanceModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterInheritanceModifier(s) + } +} + +func (s *InheritanceModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitInheritanceModifier(s) + } +} + +func (p *KotlinParser) InheritanceModifier() (localctx IInheritanceModifierContext) { + this := p + _ = this + + localctx = NewInheritanceModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, KotlinParserRULE_inheritanceModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3405) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-125)) & ^0x3f) == 0 && ((int64(1)<<(_la-125))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IParameterModifierContext is an interface to support dynamic dispatch. +type IParameterModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsParameterModifierContext differentiates from other interfaces. + IsParameterModifierContext() +} + +type ParameterModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterModifierContext() *ParameterModifierContext { + var p = new(ParameterModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_parameterModifier + return p +} + +func (*ParameterModifierContext) IsParameterModifierContext() {} + +func NewParameterModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterModifierContext { + var p = new(ParameterModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_parameterModifier + + return p +} + +func (s *ParameterModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterModifierContext) VARARG() antlr.TerminalNode { + return s.GetToken(KotlinParserVARARG, 0) +} + +func (s *ParameterModifierContext) NOINLINE() antlr.TerminalNode { + return s.GetToken(KotlinParserNOINLINE, 0) +} + +func (s *ParameterModifierContext) CROSSINLINE() antlr.TerminalNode { + return s.GetToken(KotlinParserCROSSINLINE, 0) +} + +func (s *ParameterModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterParameterModifier(s) + } +} + +func (s *ParameterModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitParameterModifier(s) + } +} + +func (p *KotlinParser) ParameterModifier() (localctx IParameterModifierContext) { + this := p + _ = this + + localctx = NewParameterModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, KotlinParserRULE_parameterModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3407) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IReificationModifierContext is an interface to support dynamic dispatch. +type IReificationModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsReificationModifierContext differentiates from other interfaces. + IsReificationModifierContext() +} + +type ReificationModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReificationModifierContext() *ReificationModifierContext { + var p = new(ReificationModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_reificationModifier + return p +} + +func (*ReificationModifierContext) IsReificationModifierContext() {} + +func NewReificationModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReificationModifierContext { + var p = new(ReificationModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_reificationModifier + + return p +} + +func (s *ReificationModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReificationModifierContext) REIFIED() antlr.TerminalNode { + return s.GetToken(KotlinParserREIFIED, 0) +} + +func (s *ReificationModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReificationModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReificationModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterReificationModifier(s) + } +} + +func (s *ReificationModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitReificationModifier(s) + } +} + +func (p *KotlinParser) ReificationModifier() (localctx IReificationModifierContext) { + this := p + _ = this + + localctx = NewReificationModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, KotlinParserRULE_reificationModifier) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3409) + p.Match(KotlinParserREIFIED) + } + + return localctx +} + +// IPlatformModifierContext is an interface to support dynamic dispatch. +type IPlatformModifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsPlatformModifierContext differentiates from other interfaces. + IsPlatformModifierContext() +} + +type PlatformModifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlatformModifierContext() *PlatformModifierContext { + var p = new(PlatformModifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_platformModifier + return p +} + +func (*PlatformModifierContext) IsPlatformModifierContext() {} + +func NewPlatformModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlatformModifierContext { + var p = new(PlatformModifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_platformModifier + + return p +} + +func (s *PlatformModifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *PlatformModifierContext) EXPECT() antlr.TerminalNode { + return s.GetToken(KotlinParserEXPECT, 0) +} + +func (s *PlatformModifierContext) ACTUAL() antlr.TerminalNode { + return s.GetToken(KotlinParserACTUAL, 0) +} + +func (s *PlatformModifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlatformModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PlatformModifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterPlatformModifier(s) + } +} + +func (s *PlatformModifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitPlatformModifier(s) + } +} + +func (p *KotlinParser) PlatformModifier() (localctx IPlatformModifierContext) { + this := p + _ = this + + localctx = NewPlatformModifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, KotlinParserRULE_platformModifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3411) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserEXPECT || _la == KotlinParserACTUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IAnnotationContext is an interface to support dynamic dispatch. +type IAnnotationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAnnotationContext differentiates from other interfaces. + IsAnnotationContext() +} + +type AnnotationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotationContext() *AnnotationContext { + var p = new(AnnotationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_annotation + return p +} + +func (*AnnotationContext) IsAnnotationContext() {} + +func NewAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationContext { + var p = new(AnnotationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_annotation + + return p +} + +func (s *AnnotationContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnnotationContext) SingleAnnotation() ISingleAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingleAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingleAnnotationContext) +} + +func (s *AnnotationContext) MultiAnnotation() IMultiAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiAnnotationContext) +} + +func (s *AnnotationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AnnotationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AnnotationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnnotationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAnnotation(s) + } +} + +func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAnnotation(s) + } +} + +func (p *KotlinParser) Annotation() (localctx IAnnotationContext) { + this := p + _ = this + + localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, KotlinParserRULE_annotation) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3415) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 524, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3413) + p.SingleAnnotation() + } + + case 2: + { + p.SetState(3414) + p.MultiAnnotation() + } + + } + p.SetState(3420) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 525, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3417) + p.Match(KotlinParserNL) + } + + } + p.SetState(3422) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 525, p.GetParserRuleContext()) + } + + return localctx +} + +// ISingleAnnotationContext is an interface to support dynamic dispatch. +type ISingleAnnotationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSingleAnnotationContext differentiates from other interfaces. + IsSingleAnnotationContext() +} + +type SingleAnnotationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySingleAnnotationContext() *SingleAnnotationContext { + var p = new(SingleAnnotationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_singleAnnotation + return p +} + +func (*SingleAnnotationContext) IsSingleAnnotationContext() {} + +func NewSingleAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleAnnotationContext { + var p = new(SingleAnnotationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_singleAnnotation + + return p +} + +func (s *SingleAnnotationContext) GetParser() antlr.Parser { return s.parser } + +func (s *SingleAnnotationContext) UnescapedAnnotation() IUnescapedAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnescapedAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnescapedAnnotationContext) +} + +func (s *SingleAnnotationContext) AnnotationUseSiteTarget() IAnnotationUseSiteTargetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationUseSiteTargetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationUseSiteTargetContext) +} + +func (s *SingleAnnotationContext) AT_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_NO_WS, 0) +} + +func (s *SingleAnnotationContext) AT_PRE_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_PRE_WS, 0) +} + +func (s *SingleAnnotationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *SingleAnnotationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *SingleAnnotationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SingleAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SingleAnnotationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSingleAnnotation(s) + } +} + +func (s *SingleAnnotationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSingleAnnotation(s) + } +} + +func (p *KotlinParser) SingleAnnotation() (localctx ISingleAnnotationContext) { + this := p + _ = this + + localctx = NewSingleAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, KotlinParserRULE_singleAnnotation) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(3432) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 527, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3423) + p.AnnotationUseSiteTarget() + } + p.SetState(3427) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3424) + p.Match(KotlinParserNL) + } + + p.SetState(3429) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(3430) + p.Match(KotlinParserAT_NO_WS) + } + + case 3: + { + p.SetState(3431) + p.Match(KotlinParserAT_PRE_WS) + } + + } + { + p.SetState(3434) + p.UnescapedAnnotation() + } + + return localctx +} + +// IMultiAnnotationContext is an interface to support dynamic dispatch. +type IMultiAnnotationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsMultiAnnotationContext differentiates from other interfaces. + IsMultiAnnotationContext() +} + +type MultiAnnotationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiAnnotationContext() *MultiAnnotationContext { + var p = new(MultiAnnotationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_multiAnnotation + return p +} + +func (*MultiAnnotationContext) IsMultiAnnotationContext() {} + +func NewMultiAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiAnnotationContext { + var p = new(MultiAnnotationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_multiAnnotation + + return p +} + +func (s *MultiAnnotationContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiAnnotationContext) LSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserLSQUARE, 0) +} + +func (s *MultiAnnotationContext) RSQUARE() antlr.TerminalNode { + return s.GetToken(KotlinParserRSQUARE, 0) +} + +func (s *MultiAnnotationContext) AnnotationUseSiteTarget() IAnnotationUseSiteTargetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationUseSiteTargetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationUseSiteTargetContext) +} + +func (s *MultiAnnotationContext) AT_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_NO_WS, 0) +} + +func (s *MultiAnnotationContext) AT_PRE_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_PRE_WS, 0) +} + +func (s *MultiAnnotationContext) AllUnescapedAnnotation() []IUnescapedAnnotationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnescapedAnnotationContext); ok { + len++ + } + } + + tst := make([]IUnescapedAnnotationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnescapedAnnotationContext); ok { + tst[i] = t.(IUnescapedAnnotationContext) + i++ + } + } + + return tst +} + +func (s *MultiAnnotationContext) UnescapedAnnotation(i int) IUnescapedAnnotationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnescapedAnnotationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnescapedAnnotationContext) +} + +func (s *MultiAnnotationContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *MultiAnnotationContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *MultiAnnotationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiAnnotationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterMultiAnnotation(s) + } +} + +func (s *MultiAnnotationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitMultiAnnotation(s) + } +} + +func (p *KotlinParser) MultiAnnotation() (localctx IMultiAnnotationContext) { + this := p + _ = this + + localctx = NewMultiAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, KotlinParserRULE_multiAnnotation) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + p.SetState(3445) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 529, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3436) + p.AnnotationUseSiteTarget() + } + p.SetState(3440) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3437) + p.Match(KotlinParserNL) + } + + p.SetState(3442) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(3443) + p.Match(KotlinParserAT_NO_WS) + } + + case 3: + { + p.SetState(3444) + p.Match(KotlinParserAT_PRE_WS) + } + + } + { + p.SetState(3447) + p.Match(KotlinParserLSQUARE) + } + p.SetState(3449) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = (int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&-17588927330817) != 0 || (int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&2098175) != 0 { + { + p.SetState(3448) + p.UnescapedAnnotation() + } + + p.SetState(3451) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3453) + p.Match(KotlinParserRSQUARE) + } + + return localctx +} + +// IAnnotationUseSiteTargetContext is an interface to support dynamic dispatch. +type IAnnotationUseSiteTargetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsAnnotationUseSiteTargetContext differentiates from other interfaces. + IsAnnotationUseSiteTargetContext() +} + +type AnnotationUseSiteTargetContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotationUseSiteTargetContext() *AnnotationUseSiteTargetContext { + var p = new(AnnotationUseSiteTargetContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_annotationUseSiteTarget + return p +} + +func (*AnnotationUseSiteTargetContext) IsAnnotationUseSiteTargetContext() {} + +func NewAnnotationUseSiteTargetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationUseSiteTargetContext { + var p = new(AnnotationUseSiteTargetContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_annotationUseSiteTarget + + return p +} + +func (s *AnnotationUseSiteTargetContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnnotationUseSiteTargetContext) COLON() antlr.TerminalNode { + return s.GetToken(KotlinParserCOLON, 0) +} + +func (s *AnnotationUseSiteTargetContext) AT_NO_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_NO_WS, 0) +} + +func (s *AnnotationUseSiteTargetContext) AT_PRE_WS() antlr.TerminalNode { + return s.GetToken(KotlinParserAT_PRE_WS, 0) +} + +func (s *AnnotationUseSiteTargetContext) FIELD() antlr.TerminalNode { + return s.GetToken(KotlinParserFIELD, 0) +} + +func (s *AnnotationUseSiteTargetContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(KotlinParserPROPERTY, 0) +} + +func (s *AnnotationUseSiteTargetContext) GET() antlr.TerminalNode { + return s.GetToken(KotlinParserGET, 0) +} + +func (s *AnnotationUseSiteTargetContext) SET() antlr.TerminalNode { + return s.GetToken(KotlinParserSET, 0) +} + +func (s *AnnotationUseSiteTargetContext) RECEIVER() antlr.TerminalNode { + return s.GetToken(KotlinParserRECEIVER, 0) +} + +func (s *AnnotationUseSiteTargetContext) PARAM() antlr.TerminalNode { + return s.GetToken(KotlinParserPARAM, 0) +} + +func (s *AnnotationUseSiteTargetContext) SETPARAM() antlr.TerminalNode { + return s.GetToken(KotlinParserSETPARAM, 0) +} + +func (s *AnnotationUseSiteTargetContext) DELEGATE() antlr.TerminalNode { + return s.GetToken(KotlinParserDELEGATE, 0) +} + +func (s *AnnotationUseSiteTargetContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *AnnotationUseSiteTargetContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *AnnotationUseSiteTargetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnnotationUseSiteTargetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnnotationUseSiteTargetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterAnnotationUseSiteTarget(s) + } +} + +func (s *AnnotationUseSiteTargetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitAnnotationUseSiteTarget(s) + } +} + +func (p *KotlinParser) AnnotationUseSiteTarget() (localctx IAnnotationUseSiteTargetContext) { + this := p + _ = this + + localctx = NewAnnotationUseSiteTargetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, KotlinParserRULE_annotationUseSiteTarget) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3455) + _la = p.GetTokenStream().LA(1) + + if !(_la == KotlinParserAT_NO_WS || _la == KotlinParserAT_PRE_WS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3456) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-63)) & ^0x3f) == 0 && ((int64(1)<<(_la-63))&255) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3460) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3457) + p.Match(KotlinParserNL) + } + + p.SetState(3462) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3463) + p.Match(KotlinParserCOLON) + } + + return localctx +} + +// IUnescapedAnnotationContext is an interface to support dynamic dispatch. +type IUnescapedAnnotationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsUnescapedAnnotationContext differentiates from other interfaces. + IsUnescapedAnnotationContext() +} + +type UnescapedAnnotationContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnescapedAnnotationContext() *UnescapedAnnotationContext { + var p = new(UnescapedAnnotationContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_unescapedAnnotation + return p +} + +func (*UnescapedAnnotationContext) IsUnescapedAnnotationContext() {} + +func NewUnescapedAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnescapedAnnotationContext { + var p = new(UnescapedAnnotationContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_unescapedAnnotation + + return p +} + +func (s *UnescapedAnnotationContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnescapedAnnotationContext) ConstructorInvocation() IConstructorInvocationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructorInvocationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructorInvocationContext) +} + +func (s *UnescapedAnnotationContext) UserType() IUserTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserTypeContext) +} + +func (s *UnescapedAnnotationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnescapedAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnescapedAnnotationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterUnescapedAnnotation(s) + } +} + +func (s *UnescapedAnnotationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitUnescapedAnnotation(s) + } +} + +func (p *KotlinParser) UnescapedAnnotation() (localctx IUnescapedAnnotationContext) { + this := p + _ = this + + localctx = NewUnescapedAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, KotlinParserRULE_unescapedAnnotation) + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.SetState(3467) + p.GetErrorHandler().Sync(p) + switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 532, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3465) + p.ConstructorInvocation() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3466) + p.UserType() + } + + } + + return localctx +} + +// ISimpleIdentifierContext is an interface to support dynamic dispatch. +type ISimpleIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsSimpleIdentifierContext differentiates from other interfaces. + IsSimpleIdentifierContext() +} + +type SimpleIdentifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimpleIdentifierContext() *SimpleIdentifierContext { + var p = new(SimpleIdentifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_simpleIdentifier + return p +} + +func (*SimpleIdentifierContext) IsSimpleIdentifierContext() {} + +func NewSimpleIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleIdentifierContext { + var p = new(SimpleIdentifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_simpleIdentifier + + return p +} + +func (s *SimpleIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleIdentifierContext) Identifier() antlr.TerminalNode { + return s.GetToken(KotlinParserIdentifier, 0) +} + +func (s *SimpleIdentifierContext) ABSTRACT() antlr.TerminalNode { + return s.GetToken(KotlinParserABSTRACT, 0) +} + +func (s *SimpleIdentifierContext) ANNOTATION() antlr.TerminalNode { + return s.GetToken(KotlinParserANNOTATION, 0) +} + +func (s *SimpleIdentifierContext) BY() antlr.TerminalNode { + return s.GetToken(KotlinParserBY, 0) +} + +func (s *SimpleIdentifierContext) CATCH() antlr.TerminalNode { + return s.GetToken(KotlinParserCATCH, 0) +} + +func (s *SimpleIdentifierContext) COMPANION() antlr.TerminalNode { + return s.GetToken(KotlinParserCOMPANION, 0) +} + +func (s *SimpleIdentifierContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(KotlinParserCONSTRUCTOR, 0) +} + +func (s *SimpleIdentifierContext) CROSSINLINE() antlr.TerminalNode { + return s.GetToken(KotlinParserCROSSINLINE, 0) +} + +func (s *SimpleIdentifierContext) DATA() antlr.TerminalNode { + return s.GetToken(KotlinParserDATA, 0) +} + +func (s *SimpleIdentifierContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(KotlinParserDYNAMIC, 0) +} + +func (s *SimpleIdentifierContext) ENUM() antlr.TerminalNode { + return s.GetToken(KotlinParserENUM, 0) +} + +func (s *SimpleIdentifierContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(KotlinParserEXTERNAL, 0) +} + +func (s *SimpleIdentifierContext) FINAL() antlr.TerminalNode { + return s.GetToken(KotlinParserFINAL, 0) +} + +func (s *SimpleIdentifierContext) FINALLY() antlr.TerminalNode { + return s.GetToken(KotlinParserFINALLY, 0) +} + +func (s *SimpleIdentifierContext) GET() antlr.TerminalNode { + return s.GetToken(KotlinParserGET, 0) +} + +func (s *SimpleIdentifierContext) IMPORT() antlr.TerminalNode { + return s.GetToken(KotlinParserIMPORT, 0) +} + +func (s *SimpleIdentifierContext) INFIX() antlr.TerminalNode { + return s.GetToken(KotlinParserINFIX, 0) +} + +func (s *SimpleIdentifierContext) INIT() antlr.TerminalNode { + return s.GetToken(KotlinParserINIT, 0) +} + +func (s *SimpleIdentifierContext) INLINE() antlr.TerminalNode { + return s.GetToken(KotlinParserINLINE, 0) +} + +func (s *SimpleIdentifierContext) INNER() antlr.TerminalNode { + return s.GetToken(KotlinParserINNER, 0) +} + +func (s *SimpleIdentifierContext) INTERNAL() antlr.TerminalNode { + return s.GetToken(KotlinParserINTERNAL, 0) +} + +func (s *SimpleIdentifierContext) LATEINIT() antlr.TerminalNode { + return s.GetToken(KotlinParserLATEINIT, 0) +} + +func (s *SimpleIdentifierContext) NOINLINE() antlr.TerminalNode { + return s.GetToken(KotlinParserNOINLINE, 0) +} + +func (s *SimpleIdentifierContext) OPEN() antlr.TerminalNode { + return s.GetToken(KotlinParserOPEN, 0) +} + +func (s *SimpleIdentifierContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(KotlinParserOPERATOR, 0) +} + +func (s *SimpleIdentifierContext) OUT() antlr.TerminalNode { + return s.GetToken(KotlinParserOUT, 0) +} + +func (s *SimpleIdentifierContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(KotlinParserOVERRIDE, 0) +} + +func (s *SimpleIdentifierContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(KotlinParserPRIVATE, 0) +} + +func (s *SimpleIdentifierContext) PROTECTED() antlr.TerminalNode { + return s.GetToken(KotlinParserPROTECTED, 0) +} + +func (s *SimpleIdentifierContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(KotlinParserPUBLIC, 0) +} + +func (s *SimpleIdentifierContext) REIFIED() antlr.TerminalNode { + return s.GetToken(KotlinParserREIFIED, 0) +} + +func (s *SimpleIdentifierContext) SEALED() antlr.TerminalNode { + return s.GetToken(KotlinParserSEALED, 0) +} + +func (s *SimpleIdentifierContext) TAILREC() antlr.TerminalNode { + return s.GetToken(KotlinParserTAILREC, 0) +} + +func (s *SimpleIdentifierContext) SET() antlr.TerminalNode { + return s.GetToken(KotlinParserSET, 0) +} + +func (s *SimpleIdentifierContext) VARARG() antlr.TerminalNode { + return s.GetToken(KotlinParserVARARG, 0) +} + +func (s *SimpleIdentifierContext) WHERE() antlr.TerminalNode { + return s.GetToken(KotlinParserWHERE, 0) +} + +func (s *SimpleIdentifierContext) FIELD() antlr.TerminalNode { + return s.GetToken(KotlinParserFIELD, 0) +} + +func (s *SimpleIdentifierContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(KotlinParserPROPERTY, 0) +} + +func (s *SimpleIdentifierContext) RECEIVER() antlr.TerminalNode { + return s.GetToken(KotlinParserRECEIVER, 0) +} + +func (s *SimpleIdentifierContext) PARAM() antlr.TerminalNode { + return s.GetToken(KotlinParserPARAM, 0) +} + +func (s *SimpleIdentifierContext) SETPARAM() antlr.TerminalNode { + return s.GetToken(KotlinParserSETPARAM, 0) +} + +func (s *SimpleIdentifierContext) DELEGATE() antlr.TerminalNode { + return s.GetToken(KotlinParserDELEGATE, 0) +} + +func (s *SimpleIdentifierContext) FILE() antlr.TerminalNode { + return s.GetToken(KotlinParserFILE, 0) +} + +func (s *SimpleIdentifierContext) EXPECT() antlr.TerminalNode { + return s.GetToken(KotlinParserEXPECT, 0) +} + +func (s *SimpleIdentifierContext) ACTUAL() antlr.TerminalNode { + return s.GetToken(KotlinParserACTUAL, 0) +} + +func (s *SimpleIdentifierContext) CONST() antlr.TerminalNode { + return s.GetToken(KotlinParserCONST, 0) +} + +func (s *SimpleIdentifierContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(KotlinParserSUSPEND, 0) +} + +func (s *SimpleIdentifierContext) VALUE() antlr.TerminalNode { + return s.GetToken(KotlinParserVALUE, 0) +} + +func (s *SimpleIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterSimpleIdentifier(s) + } +} + +func (s *SimpleIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitSimpleIdentifier(s) + } +} + +func (p *KotlinParser) SimpleIdentifier() (localctx ISimpleIdentifierContext) { + this := p + _ = this + + localctx = NewSimpleIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, KotlinParserRULE_simpleIdentifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3469) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&-17588927330817) != 0 || (int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&2098175) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + return localctx +} + +// IIdentifierContext is an interface to support dynamic dispatch. +type IIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // IsIdentifierContext differentiates from other interfaces. + IsIdentifierContext() +} + +type IdentifierContext struct { + *antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierContext() *IdentifierContext { + var p = new(IdentifierContext) + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) + p.RuleIndex = KotlinParserRULE_identifier + return p +} + +func (*IdentifierContext) IsIdentifierContext() {} + +func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext { + var p = new(IdentifierContext) + + p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) + + p.parser = parser + p.RuleIndex = KotlinParserRULE_identifier + + return p +} + +func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierContext) AllSimpleIdentifier() []ISimpleIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + len++ + } + } + + tst := make([]ISimpleIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimpleIdentifierContext); ok { + tst[i] = t.(ISimpleIdentifierContext) + i++ + } + } + + return tst +} + +func (s *IdentifierContext) SimpleIdentifier(i int) ISimpleIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimpleIdentifierContext) +} + +func (s *IdentifierContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(KotlinParserDOT) +} + +func (s *IdentifierContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserDOT, i) +} + +func (s *IdentifierContext) AllNL() []antlr.TerminalNode { + return s.GetTokens(KotlinParserNL) +} + +func (s *IdentifierContext) NL(i int) antlr.TerminalNode { + return s.GetToken(KotlinParserNL, i) +} + +func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.EnterIdentifier(s) + } +} + +func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(KotlinParserListener); ok { + listenerT.ExitIdentifier(s) + } +} + +func (p *KotlinParser) Identifier() (localctx IIdentifierContext) { + this := p + _ = this + + localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, KotlinParserRULE_identifier) + var _la int + + defer func() { + p.ExitRule() + }() + + defer func() { + if err := recover(); err != nil { + if v, ok := err.(antlr.RecognitionException); ok { + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + } else { + panic(err) + } + } + }() + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3471) + p.SimpleIdentifier() + } + p.SetState(3482) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 534, p.GetParserRuleContext()) + + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3475) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + + for _la == KotlinParserNL { + { + p.SetState(3472) + p.Match(KotlinParserNL) + } + + p.SetState(3477) + p.GetErrorHandler().Sync(p) + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3478) + p.Match(KotlinParserDOT) + } + { + p.SetState(3479) + p.SimpleIdentifier() + } + + } + p.SetState(3484) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 534, p.GetParserRuleContext()) + } + + return localctx +} diff --git a/lib/archer/kotlin_parser/kotlinparser_base_listener.go b/lib/archer/kotlin_parser/kotlinparser_base_listener.go new file mode 100644 index 0000000..65092ca --- /dev/null +++ b/lib/archer/kotlin_parser/kotlinparser_base_listener.go @@ -0,0 +1,1096 @@ +// Code generated from java-escape by ANTLR 4.11.1. DO NOT EDIT. + +package kotlin_parser // KotlinParser +import "github.com/antlr/antlr4/runtime/Go/antlr/v4" + +// BaseKotlinParserListener is a complete listener for a parse tree produced by KotlinParser. +type BaseKotlinParserListener struct{} + +var _ KotlinParserListener = &BaseKotlinParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseKotlinParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseKotlinParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseKotlinParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseKotlinParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterKotlinFile is called when production kotlinFile is entered. +func (s *BaseKotlinParserListener) EnterKotlinFile(ctx *KotlinFileContext) {} + +// ExitKotlinFile is called when production kotlinFile is exited. +func (s *BaseKotlinParserListener) ExitKotlinFile(ctx *KotlinFileContext) {} + +// EnterScript is called when production script is entered. +func (s *BaseKotlinParserListener) EnterScript(ctx *ScriptContext) {} + +// ExitScript is called when production script is exited. +func (s *BaseKotlinParserListener) ExitScript(ctx *ScriptContext) {} + +// EnterShebangLine is called when production shebangLine is entered. +func (s *BaseKotlinParserListener) EnterShebangLine(ctx *ShebangLineContext) {} + +// ExitShebangLine is called when production shebangLine is exited. +func (s *BaseKotlinParserListener) ExitShebangLine(ctx *ShebangLineContext) {} + +// EnterFileAnnotation is called when production fileAnnotation is entered. +func (s *BaseKotlinParserListener) EnterFileAnnotation(ctx *FileAnnotationContext) {} + +// ExitFileAnnotation is called when production fileAnnotation is exited. +func (s *BaseKotlinParserListener) ExitFileAnnotation(ctx *FileAnnotationContext) {} + +// EnterPackageHeader is called when production packageHeader is entered. +func (s *BaseKotlinParserListener) EnterPackageHeader(ctx *PackageHeaderContext) {} + +// ExitPackageHeader is called when production packageHeader is exited. +func (s *BaseKotlinParserListener) ExitPackageHeader(ctx *PackageHeaderContext) {} + +// EnterImportList is called when production importList is entered. +func (s *BaseKotlinParserListener) EnterImportList(ctx *ImportListContext) {} + +// ExitImportList is called when production importList is exited. +func (s *BaseKotlinParserListener) ExitImportList(ctx *ImportListContext) {} + +// EnterImportHeader is called when production importHeader is entered. +func (s *BaseKotlinParserListener) EnterImportHeader(ctx *ImportHeaderContext) {} + +// ExitImportHeader is called when production importHeader is exited. +func (s *BaseKotlinParserListener) ExitImportHeader(ctx *ImportHeaderContext) {} + +// EnterImportAlias is called when production importAlias is entered. +func (s *BaseKotlinParserListener) EnterImportAlias(ctx *ImportAliasContext) {} + +// ExitImportAlias is called when production importAlias is exited. +func (s *BaseKotlinParserListener) ExitImportAlias(ctx *ImportAliasContext) {} + +// EnterTopLevelObject is called when production topLevelObject is entered. +func (s *BaseKotlinParserListener) EnterTopLevelObject(ctx *TopLevelObjectContext) {} + +// ExitTopLevelObject is called when production topLevelObject is exited. +func (s *BaseKotlinParserListener) ExitTopLevelObject(ctx *TopLevelObjectContext) {} + +// EnterTypeAlias is called when production typeAlias is entered. +func (s *BaseKotlinParserListener) EnterTypeAlias(ctx *TypeAliasContext) {} + +// ExitTypeAlias is called when production typeAlias is exited. +func (s *BaseKotlinParserListener) ExitTypeAlias(ctx *TypeAliasContext) {} + +// EnterDeclaration is called when production declaration is entered. +func (s *BaseKotlinParserListener) EnterDeclaration(ctx *DeclarationContext) {} + +// ExitDeclaration is called when production declaration is exited. +func (s *BaseKotlinParserListener) ExitDeclaration(ctx *DeclarationContext) {} + +// EnterClassDeclaration is called when production classDeclaration is entered. +func (s *BaseKotlinParserListener) EnterClassDeclaration(ctx *ClassDeclarationContext) {} + +// ExitClassDeclaration is called when production classDeclaration is exited. +func (s *BaseKotlinParserListener) ExitClassDeclaration(ctx *ClassDeclarationContext) {} + +// EnterPrimaryConstructor is called when production primaryConstructor is entered. +func (s *BaseKotlinParserListener) EnterPrimaryConstructor(ctx *PrimaryConstructorContext) {} + +// ExitPrimaryConstructor is called when production primaryConstructor is exited. +func (s *BaseKotlinParserListener) ExitPrimaryConstructor(ctx *PrimaryConstructorContext) {} + +// EnterClassBody is called when production classBody is entered. +func (s *BaseKotlinParserListener) EnterClassBody(ctx *ClassBodyContext) {} + +// ExitClassBody is called when production classBody is exited. +func (s *BaseKotlinParserListener) ExitClassBody(ctx *ClassBodyContext) {} + +// EnterClassParameters is called when production classParameters is entered. +func (s *BaseKotlinParserListener) EnterClassParameters(ctx *ClassParametersContext) {} + +// ExitClassParameters is called when production classParameters is exited. +func (s *BaseKotlinParserListener) ExitClassParameters(ctx *ClassParametersContext) {} + +// EnterClassParameter is called when production classParameter is entered. +func (s *BaseKotlinParserListener) EnterClassParameter(ctx *ClassParameterContext) {} + +// ExitClassParameter is called when production classParameter is exited. +func (s *BaseKotlinParserListener) ExitClassParameter(ctx *ClassParameterContext) {} + +// EnterDelegationSpecifiers is called when production delegationSpecifiers is entered. +func (s *BaseKotlinParserListener) EnterDelegationSpecifiers(ctx *DelegationSpecifiersContext) {} + +// ExitDelegationSpecifiers is called when production delegationSpecifiers is exited. +func (s *BaseKotlinParserListener) ExitDelegationSpecifiers(ctx *DelegationSpecifiersContext) {} + +// EnterDelegationSpecifier is called when production delegationSpecifier is entered. +func (s *BaseKotlinParserListener) EnterDelegationSpecifier(ctx *DelegationSpecifierContext) {} + +// ExitDelegationSpecifier is called when production delegationSpecifier is exited. +func (s *BaseKotlinParserListener) ExitDelegationSpecifier(ctx *DelegationSpecifierContext) {} + +// EnterConstructorInvocation is called when production constructorInvocation is entered. +func (s *BaseKotlinParserListener) EnterConstructorInvocation(ctx *ConstructorInvocationContext) {} + +// ExitConstructorInvocation is called when production constructorInvocation is exited. +func (s *BaseKotlinParserListener) ExitConstructorInvocation(ctx *ConstructorInvocationContext) {} + +// EnterAnnotatedDelegationSpecifier is called when production annotatedDelegationSpecifier is entered. +func (s *BaseKotlinParserListener) EnterAnnotatedDelegationSpecifier(ctx *AnnotatedDelegationSpecifierContext) { +} + +// ExitAnnotatedDelegationSpecifier is called when production annotatedDelegationSpecifier is exited. +func (s *BaseKotlinParserListener) ExitAnnotatedDelegationSpecifier(ctx *AnnotatedDelegationSpecifierContext) { +} + +// EnterExplicitDelegation is called when production explicitDelegation is entered. +func (s *BaseKotlinParserListener) EnterExplicitDelegation(ctx *ExplicitDelegationContext) {} + +// ExitExplicitDelegation is called when production explicitDelegation is exited. +func (s *BaseKotlinParserListener) ExitExplicitDelegation(ctx *ExplicitDelegationContext) {} + +// EnterTypeParameters is called when production typeParameters is entered. +func (s *BaseKotlinParserListener) EnterTypeParameters(ctx *TypeParametersContext) {} + +// ExitTypeParameters is called when production typeParameters is exited. +func (s *BaseKotlinParserListener) ExitTypeParameters(ctx *TypeParametersContext) {} + +// EnterTypeParameter is called when production typeParameter is entered. +func (s *BaseKotlinParserListener) EnterTypeParameter(ctx *TypeParameterContext) {} + +// ExitTypeParameter is called when production typeParameter is exited. +func (s *BaseKotlinParserListener) ExitTypeParameter(ctx *TypeParameterContext) {} + +// EnterTypeConstraints is called when production typeConstraints is entered. +func (s *BaseKotlinParserListener) EnterTypeConstraints(ctx *TypeConstraintsContext) {} + +// ExitTypeConstraints is called when production typeConstraints is exited. +func (s *BaseKotlinParserListener) ExitTypeConstraints(ctx *TypeConstraintsContext) {} + +// EnterTypeConstraint is called when production typeConstraint is entered. +func (s *BaseKotlinParserListener) EnterTypeConstraint(ctx *TypeConstraintContext) {} + +// ExitTypeConstraint is called when production typeConstraint is exited. +func (s *BaseKotlinParserListener) ExitTypeConstraint(ctx *TypeConstraintContext) {} + +// EnterClassMemberDeclarations is called when production classMemberDeclarations is entered. +func (s *BaseKotlinParserListener) EnterClassMemberDeclarations(ctx *ClassMemberDeclarationsContext) { +} + +// ExitClassMemberDeclarations is called when production classMemberDeclarations is exited. +func (s *BaseKotlinParserListener) ExitClassMemberDeclarations(ctx *ClassMemberDeclarationsContext) {} + +// EnterClassMemberDeclaration is called when production classMemberDeclaration is entered. +func (s *BaseKotlinParserListener) EnterClassMemberDeclaration(ctx *ClassMemberDeclarationContext) {} + +// ExitClassMemberDeclaration is called when production classMemberDeclaration is exited. +func (s *BaseKotlinParserListener) ExitClassMemberDeclaration(ctx *ClassMemberDeclarationContext) {} + +// EnterAnonymousInitializer is called when production anonymousInitializer is entered. +func (s *BaseKotlinParserListener) EnterAnonymousInitializer(ctx *AnonymousInitializerContext) {} + +// ExitAnonymousInitializer is called when production anonymousInitializer is exited. +func (s *BaseKotlinParserListener) ExitAnonymousInitializer(ctx *AnonymousInitializerContext) {} + +// EnterCompanionObject is called when production companionObject is entered. +func (s *BaseKotlinParserListener) EnterCompanionObject(ctx *CompanionObjectContext) {} + +// ExitCompanionObject is called when production companionObject is exited. +func (s *BaseKotlinParserListener) ExitCompanionObject(ctx *CompanionObjectContext) {} + +// EnterFunctionValueParameters is called when production functionValueParameters is entered. +func (s *BaseKotlinParserListener) EnterFunctionValueParameters(ctx *FunctionValueParametersContext) { +} + +// ExitFunctionValueParameters is called when production functionValueParameters is exited. +func (s *BaseKotlinParserListener) ExitFunctionValueParameters(ctx *FunctionValueParametersContext) {} + +// EnterFunctionValueParameter is called when production functionValueParameter is entered. +func (s *BaseKotlinParserListener) EnterFunctionValueParameter(ctx *FunctionValueParameterContext) {} + +// ExitFunctionValueParameter is called when production functionValueParameter is exited. +func (s *BaseKotlinParserListener) ExitFunctionValueParameter(ctx *FunctionValueParameterContext) {} + +// EnterFunctionDeclaration is called when production functionDeclaration is entered. +func (s *BaseKotlinParserListener) EnterFunctionDeclaration(ctx *FunctionDeclarationContext) {} + +// ExitFunctionDeclaration is called when production functionDeclaration is exited. +func (s *BaseKotlinParserListener) ExitFunctionDeclaration(ctx *FunctionDeclarationContext) {} + +// EnterFunctionBody is called when production functionBody is entered. +func (s *BaseKotlinParserListener) EnterFunctionBody(ctx *FunctionBodyContext) {} + +// ExitFunctionBody is called when production functionBody is exited. +func (s *BaseKotlinParserListener) ExitFunctionBody(ctx *FunctionBodyContext) {} + +// EnterVariableDeclaration is called when production variableDeclaration is entered. +func (s *BaseKotlinParserListener) EnterVariableDeclaration(ctx *VariableDeclarationContext) {} + +// ExitVariableDeclaration is called when production variableDeclaration is exited. +func (s *BaseKotlinParserListener) ExitVariableDeclaration(ctx *VariableDeclarationContext) {} + +// EnterMultiVariableDeclaration is called when production multiVariableDeclaration is entered. +func (s *BaseKotlinParserListener) EnterMultiVariableDeclaration(ctx *MultiVariableDeclarationContext) { +} + +// ExitMultiVariableDeclaration is called when production multiVariableDeclaration is exited. +func (s *BaseKotlinParserListener) ExitMultiVariableDeclaration(ctx *MultiVariableDeclarationContext) { +} + +// EnterPropertyDeclaration is called when production propertyDeclaration is entered. +func (s *BaseKotlinParserListener) EnterPropertyDeclaration(ctx *PropertyDeclarationContext) {} + +// ExitPropertyDeclaration is called when production propertyDeclaration is exited. +func (s *BaseKotlinParserListener) ExitPropertyDeclaration(ctx *PropertyDeclarationContext) {} + +// EnterPropertyDelegate is called when production propertyDelegate is entered. +func (s *BaseKotlinParserListener) EnterPropertyDelegate(ctx *PropertyDelegateContext) {} + +// ExitPropertyDelegate is called when production propertyDelegate is exited. +func (s *BaseKotlinParserListener) ExitPropertyDelegate(ctx *PropertyDelegateContext) {} + +// EnterGetter is called when production getter is entered. +func (s *BaseKotlinParserListener) EnterGetter(ctx *GetterContext) {} + +// ExitGetter is called when production getter is exited. +func (s *BaseKotlinParserListener) ExitGetter(ctx *GetterContext) {} + +// EnterSetter is called when production setter is entered. +func (s *BaseKotlinParserListener) EnterSetter(ctx *SetterContext) {} + +// ExitSetter is called when production setter is exited. +func (s *BaseKotlinParserListener) ExitSetter(ctx *SetterContext) {} + +// EnterParametersWithOptionalType is called when production parametersWithOptionalType is entered. +func (s *BaseKotlinParserListener) EnterParametersWithOptionalType(ctx *ParametersWithOptionalTypeContext) { +} + +// ExitParametersWithOptionalType is called when production parametersWithOptionalType is exited. +func (s *BaseKotlinParserListener) ExitParametersWithOptionalType(ctx *ParametersWithOptionalTypeContext) { +} + +// EnterFunctionValueParameterWithOptionalType is called when production functionValueParameterWithOptionalType is entered. +func (s *BaseKotlinParserListener) EnterFunctionValueParameterWithOptionalType(ctx *FunctionValueParameterWithOptionalTypeContext) { +} + +// ExitFunctionValueParameterWithOptionalType is called when production functionValueParameterWithOptionalType is exited. +func (s *BaseKotlinParserListener) ExitFunctionValueParameterWithOptionalType(ctx *FunctionValueParameterWithOptionalTypeContext) { +} + +// EnterParameterWithOptionalType is called when production parameterWithOptionalType is entered. +func (s *BaseKotlinParserListener) EnterParameterWithOptionalType(ctx *ParameterWithOptionalTypeContext) { +} + +// ExitParameterWithOptionalType is called when production parameterWithOptionalType is exited. +func (s *BaseKotlinParserListener) ExitParameterWithOptionalType(ctx *ParameterWithOptionalTypeContext) { +} + +// EnterParameter is called when production parameter is entered. +func (s *BaseKotlinParserListener) EnterParameter(ctx *ParameterContext) {} + +// ExitParameter is called when production parameter is exited. +func (s *BaseKotlinParserListener) ExitParameter(ctx *ParameterContext) {} + +// EnterObjectDeclaration is called when production objectDeclaration is entered. +func (s *BaseKotlinParserListener) EnterObjectDeclaration(ctx *ObjectDeclarationContext) {} + +// ExitObjectDeclaration is called when production objectDeclaration is exited. +func (s *BaseKotlinParserListener) ExitObjectDeclaration(ctx *ObjectDeclarationContext) {} + +// EnterSecondaryConstructor is called when production secondaryConstructor is entered. +func (s *BaseKotlinParserListener) EnterSecondaryConstructor(ctx *SecondaryConstructorContext) {} + +// ExitSecondaryConstructor is called when production secondaryConstructor is exited. +func (s *BaseKotlinParserListener) ExitSecondaryConstructor(ctx *SecondaryConstructorContext) {} + +// EnterConstructorDelegationCall is called when production constructorDelegationCall is entered. +func (s *BaseKotlinParserListener) EnterConstructorDelegationCall(ctx *ConstructorDelegationCallContext) { +} + +// ExitConstructorDelegationCall is called when production constructorDelegationCall is exited. +func (s *BaseKotlinParserListener) ExitConstructorDelegationCall(ctx *ConstructorDelegationCallContext) { +} + +// EnterEnumClassBody is called when production enumClassBody is entered. +func (s *BaseKotlinParserListener) EnterEnumClassBody(ctx *EnumClassBodyContext) {} + +// ExitEnumClassBody is called when production enumClassBody is exited. +func (s *BaseKotlinParserListener) ExitEnumClassBody(ctx *EnumClassBodyContext) {} + +// EnterEnumEntries is called when production enumEntries is entered. +func (s *BaseKotlinParserListener) EnterEnumEntries(ctx *EnumEntriesContext) {} + +// ExitEnumEntries is called when production enumEntries is exited. +func (s *BaseKotlinParserListener) ExitEnumEntries(ctx *EnumEntriesContext) {} + +// EnterEnumEntry is called when production enumEntry is entered. +func (s *BaseKotlinParserListener) EnterEnumEntry(ctx *EnumEntryContext) {} + +// ExitEnumEntry is called when production enumEntry is exited. +func (s *BaseKotlinParserListener) ExitEnumEntry(ctx *EnumEntryContext) {} + +// EnterType is called when production type is entered. +func (s *BaseKotlinParserListener) EnterType(ctx *TypeContext) {} + +// ExitType is called when production type is exited. +func (s *BaseKotlinParserListener) ExitType(ctx *TypeContext) {} + +// EnterTypeReference is called when production typeReference is entered. +func (s *BaseKotlinParserListener) EnterTypeReference(ctx *TypeReferenceContext) {} + +// ExitTypeReference is called when production typeReference is exited. +func (s *BaseKotlinParserListener) ExitTypeReference(ctx *TypeReferenceContext) {} + +// EnterNullableType is called when production nullableType is entered. +func (s *BaseKotlinParserListener) EnterNullableType(ctx *NullableTypeContext) {} + +// ExitNullableType is called when production nullableType is exited. +func (s *BaseKotlinParserListener) ExitNullableType(ctx *NullableTypeContext) {} + +// EnterQuest is called when production quest is entered. +func (s *BaseKotlinParserListener) EnterQuest(ctx *QuestContext) {} + +// ExitQuest is called when production quest is exited. +func (s *BaseKotlinParserListener) ExitQuest(ctx *QuestContext) {} + +// EnterUserType is called when production userType is entered. +func (s *BaseKotlinParserListener) EnterUserType(ctx *UserTypeContext) {} + +// ExitUserType is called when production userType is exited. +func (s *BaseKotlinParserListener) ExitUserType(ctx *UserTypeContext) {} + +// EnterSimpleUserType is called when production simpleUserType is entered. +func (s *BaseKotlinParserListener) EnterSimpleUserType(ctx *SimpleUserTypeContext) {} + +// ExitSimpleUserType is called when production simpleUserType is exited. +func (s *BaseKotlinParserListener) ExitSimpleUserType(ctx *SimpleUserTypeContext) {} + +// EnterTypeProjection is called when production typeProjection is entered. +func (s *BaseKotlinParserListener) EnterTypeProjection(ctx *TypeProjectionContext) {} + +// ExitTypeProjection is called when production typeProjection is exited. +func (s *BaseKotlinParserListener) ExitTypeProjection(ctx *TypeProjectionContext) {} + +// EnterTypeProjectionModifiers is called when production typeProjectionModifiers is entered. +func (s *BaseKotlinParserListener) EnterTypeProjectionModifiers(ctx *TypeProjectionModifiersContext) { +} + +// ExitTypeProjectionModifiers is called when production typeProjectionModifiers is exited. +func (s *BaseKotlinParserListener) ExitTypeProjectionModifiers(ctx *TypeProjectionModifiersContext) {} + +// EnterTypeProjectionModifier is called when production typeProjectionModifier is entered. +func (s *BaseKotlinParserListener) EnterTypeProjectionModifier(ctx *TypeProjectionModifierContext) {} + +// ExitTypeProjectionModifier is called when production typeProjectionModifier is exited. +func (s *BaseKotlinParserListener) ExitTypeProjectionModifier(ctx *TypeProjectionModifierContext) {} + +// EnterFunctionType is called when production functionType is entered. +func (s *BaseKotlinParserListener) EnterFunctionType(ctx *FunctionTypeContext) {} + +// ExitFunctionType is called when production functionType is exited. +func (s *BaseKotlinParserListener) ExitFunctionType(ctx *FunctionTypeContext) {} + +// EnterFunctionTypeParameters is called when production functionTypeParameters is entered. +func (s *BaseKotlinParserListener) EnterFunctionTypeParameters(ctx *FunctionTypeParametersContext) {} + +// ExitFunctionTypeParameters is called when production functionTypeParameters is exited. +func (s *BaseKotlinParserListener) ExitFunctionTypeParameters(ctx *FunctionTypeParametersContext) {} + +// EnterParenthesizedType is called when production parenthesizedType is entered. +func (s *BaseKotlinParserListener) EnterParenthesizedType(ctx *ParenthesizedTypeContext) {} + +// ExitParenthesizedType is called when production parenthesizedType is exited. +func (s *BaseKotlinParserListener) ExitParenthesizedType(ctx *ParenthesizedTypeContext) {} + +// EnterReceiverType is called when production receiverType is entered. +func (s *BaseKotlinParserListener) EnterReceiverType(ctx *ReceiverTypeContext) {} + +// ExitReceiverType is called when production receiverType is exited. +func (s *BaseKotlinParserListener) ExitReceiverType(ctx *ReceiverTypeContext) {} + +// EnterParenthesizedUserType is called when production parenthesizedUserType is entered. +func (s *BaseKotlinParserListener) EnterParenthesizedUserType(ctx *ParenthesizedUserTypeContext) {} + +// ExitParenthesizedUserType is called when production parenthesizedUserType is exited. +func (s *BaseKotlinParserListener) ExitParenthesizedUserType(ctx *ParenthesizedUserTypeContext) {} + +// EnterDefinitelyNonNullableType is called when production definitelyNonNullableType is entered. +func (s *BaseKotlinParserListener) EnterDefinitelyNonNullableType(ctx *DefinitelyNonNullableTypeContext) { +} + +// ExitDefinitelyNonNullableType is called when production definitelyNonNullableType is exited. +func (s *BaseKotlinParserListener) ExitDefinitelyNonNullableType(ctx *DefinitelyNonNullableTypeContext) { +} + +// EnterStatements is called when production statements is entered. +func (s *BaseKotlinParserListener) EnterStatements(ctx *StatementsContext) {} + +// ExitStatements is called when production statements is exited. +func (s *BaseKotlinParserListener) ExitStatements(ctx *StatementsContext) {} + +// EnterStatement is called when production statement is entered. +func (s *BaseKotlinParserListener) EnterStatement(ctx *StatementContext) {} + +// ExitStatement is called when production statement is exited. +func (s *BaseKotlinParserListener) ExitStatement(ctx *StatementContext) {} + +// EnterLabel is called when production label is entered. +func (s *BaseKotlinParserListener) EnterLabel(ctx *LabelContext) {} + +// ExitLabel is called when production label is exited. +func (s *BaseKotlinParserListener) ExitLabel(ctx *LabelContext) {} + +// EnterControlStructureBody is called when production controlStructureBody is entered. +func (s *BaseKotlinParserListener) EnterControlStructureBody(ctx *ControlStructureBodyContext) {} + +// ExitControlStructureBody is called when production controlStructureBody is exited. +func (s *BaseKotlinParserListener) ExitControlStructureBody(ctx *ControlStructureBodyContext) {} + +// EnterBlock is called when production block is entered. +func (s *BaseKotlinParserListener) EnterBlock(ctx *BlockContext) {} + +// ExitBlock is called when production block is exited. +func (s *BaseKotlinParserListener) ExitBlock(ctx *BlockContext) {} + +// EnterLoopStatement is called when production loopStatement is entered. +func (s *BaseKotlinParserListener) EnterLoopStatement(ctx *LoopStatementContext) {} + +// ExitLoopStatement is called when production loopStatement is exited. +func (s *BaseKotlinParserListener) ExitLoopStatement(ctx *LoopStatementContext) {} + +// EnterForStatement is called when production forStatement is entered. +func (s *BaseKotlinParserListener) EnterForStatement(ctx *ForStatementContext) {} + +// ExitForStatement is called when production forStatement is exited. +func (s *BaseKotlinParserListener) ExitForStatement(ctx *ForStatementContext) {} + +// EnterWhileStatement is called when production whileStatement is entered. +func (s *BaseKotlinParserListener) EnterWhileStatement(ctx *WhileStatementContext) {} + +// ExitWhileStatement is called when production whileStatement is exited. +func (s *BaseKotlinParserListener) ExitWhileStatement(ctx *WhileStatementContext) {} + +// EnterDoWhileStatement is called when production doWhileStatement is entered. +func (s *BaseKotlinParserListener) EnterDoWhileStatement(ctx *DoWhileStatementContext) {} + +// ExitDoWhileStatement is called when production doWhileStatement is exited. +func (s *BaseKotlinParserListener) ExitDoWhileStatement(ctx *DoWhileStatementContext) {} + +// EnterAssignment is called when production assignment is entered. +func (s *BaseKotlinParserListener) EnterAssignment(ctx *AssignmentContext) {} + +// ExitAssignment is called when production assignment is exited. +func (s *BaseKotlinParserListener) ExitAssignment(ctx *AssignmentContext) {} + +// EnterSemi is called when production semi is entered. +func (s *BaseKotlinParserListener) EnterSemi(ctx *SemiContext) {} + +// ExitSemi is called when production semi is exited. +func (s *BaseKotlinParserListener) ExitSemi(ctx *SemiContext) {} + +// EnterSemis is called when production semis is entered. +func (s *BaseKotlinParserListener) EnterSemis(ctx *SemisContext) {} + +// ExitSemis is called when production semis is exited. +func (s *BaseKotlinParserListener) ExitSemis(ctx *SemisContext) {} + +// EnterExpression is called when production expression is entered. +func (s *BaseKotlinParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BaseKotlinParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterDisjunction is called when production disjunction is entered. +func (s *BaseKotlinParserListener) EnterDisjunction(ctx *DisjunctionContext) {} + +// ExitDisjunction is called when production disjunction is exited. +func (s *BaseKotlinParserListener) ExitDisjunction(ctx *DisjunctionContext) {} + +// EnterConjunction is called when production conjunction is entered. +func (s *BaseKotlinParserListener) EnterConjunction(ctx *ConjunctionContext) {} + +// ExitConjunction is called when production conjunction is exited. +func (s *BaseKotlinParserListener) ExitConjunction(ctx *ConjunctionContext) {} + +// EnterEquality is called when production equality is entered. +func (s *BaseKotlinParserListener) EnterEquality(ctx *EqualityContext) {} + +// ExitEquality is called when production equality is exited. +func (s *BaseKotlinParserListener) ExitEquality(ctx *EqualityContext) {} + +// EnterComparison is called when production comparison is entered. +func (s *BaseKotlinParserListener) EnterComparison(ctx *ComparisonContext) {} + +// ExitComparison is called when production comparison is exited. +func (s *BaseKotlinParserListener) ExitComparison(ctx *ComparisonContext) {} + +// EnterGenericCallLikeComparison is called when production genericCallLikeComparison is entered. +func (s *BaseKotlinParserListener) EnterGenericCallLikeComparison(ctx *GenericCallLikeComparisonContext) { +} + +// ExitGenericCallLikeComparison is called when production genericCallLikeComparison is exited. +func (s *BaseKotlinParserListener) ExitGenericCallLikeComparison(ctx *GenericCallLikeComparisonContext) { +} + +// EnterInfixOperation is called when production infixOperation is entered. +func (s *BaseKotlinParserListener) EnterInfixOperation(ctx *InfixOperationContext) {} + +// ExitInfixOperation is called when production infixOperation is exited. +func (s *BaseKotlinParserListener) ExitInfixOperation(ctx *InfixOperationContext) {} + +// EnterElvisExpression is called when production elvisExpression is entered. +func (s *BaseKotlinParserListener) EnterElvisExpression(ctx *ElvisExpressionContext) {} + +// ExitElvisExpression is called when production elvisExpression is exited. +func (s *BaseKotlinParserListener) ExitElvisExpression(ctx *ElvisExpressionContext) {} + +// EnterElvis is called when production elvis is entered. +func (s *BaseKotlinParserListener) EnterElvis(ctx *ElvisContext) {} + +// ExitElvis is called when production elvis is exited. +func (s *BaseKotlinParserListener) ExitElvis(ctx *ElvisContext) {} + +// EnterInfixFunctionCall is called when production infixFunctionCall is entered. +func (s *BaseKotlinParserListener) EnterInfixFunctionCall(ctx *InfixFunctionCallContext) {} + +// ExitInfixFunctionCall is called when production infixFunctionCall is exited. +func (s *BaseKotlinParserListener) ExitInfixFunctionCall(ctx *InfixFunctionCallContext) {} + +// EnterRangeExpression is called when production rangeExpression is entered. +func (s *BaseKotlinParserListener) EnterRangeExpression(ctx *RangeExpressionContext) {} + +// ExitRangeExpression is called when production rangeExpression is exited. +func (s *BaseKotlinParserListener) ExitRangeExpression(ctx *RangeExpressionContext) {} + +// EnterAdditiveExpression is called when production additiveExpression is entered. +func (s *BaseKotlinParserListener) EnterAdditiveExpression(ctx *AdditiveExpressionContext) {} + +// ExitAdditiveExpression is called when production additiveExpression is exited. +func (s *BaseKotlinParserListener) ExitAdditiveExpression(ctx *AdditiveExpressionContext) {} + +// EnterMultiplicativeExpression is called when production multiplicativeExpression is entered. +func (s *BaseKotlinParserListener) EnterMultiplicativeExpression(ctx *MultiplicativeExpressionContext) { +} + +// ExitMultiplicativeExpression is called when production multiplicativeExpression is exited. +func (s *BaseKotlinParserListener) ExitMultiplicativeExpression(ctx *MultiplicativeExpressionContext) { +} + +// EnterAsExpression is called when production asExpression is entered. +func (s *BaseKotlinParserListener) EnterAsExpression(ctx *AsExpressionContext) {} + +// ExitAsExpression is called when production asExpression is exited. +func (s *BaseKotlinParserListener) ExitAsExpression(ctx *AsExpressionContext) {} + +// EnterPrefixUnaryExpression is called when production prefixUnaryExpression is entered. +func (s *BaseKotlinParserListener) EnterPrefixUnaryExpression(ctx *PrefixUnaryExpressionContext) {} + +// ExitPrefixUnaryExpression is called when production prefixUnaryExpression is exited. +func (s *BaseKotlinParserListener) ExitPrefixUnaryExpression(ctx *PrefixUnaryExpressionContext) {} + +// EnterUnaryPrefix is called when production unaryPrefix is entered. +func (s *BaseKotlinParserListener) EnterUnaryPrefix(ctx *UnaryPrefixContext) {} + +// ExitUnaryPrefix is called when production unaryPrefix is exited. +func (s *BaseKotlinParserListener) ExitUnaryPrefix(ctx *UnaryPrefixContext) {} + +// EnterPostfixUnaryExpression is called when production postfixUnaryExpression is entered. +func (s *BaseKotlinParserListener) EnterPostfixUnaryExpression(ctx *PostfixUnaryExpressionContext) {} + +// ExitPostfixUnaryExpression is called when production postfixUnaryExpression is exited. +func (s *BaseKotlinParserListener) ExitPostfixUnaryExpression(ctx *PostfixUnaryExpressionContext) {} + +// EnterPostfixUnarySuffix is called when production postfixUnarySuffix is entered. +func (s *BaseKotlinParserListener) EnterPostfixUnarySuffix(ctx *PostfixUnarySuffixContext) {} + +// ExitPostfixUnarySuffix is called when production postfixUnarySuffix is exited. +func (s *BaseKotlinParserListener) ExitPostfixUnarySuffix(ctx *PostfixUnarySuffixContext) {} + +// EnterDirectlyAssignableExpression is called when production directlyAssignableExpression is entered. +func (s *BaseKotlinParserListener) EnterDirectlyAssignableExpression(ctx *DirectlyAssignableExpressionContext) { +} + +// ExitDirectlyAssignableExpression is called when production directlyAssignableExpression is exited. +func (s *BaseKotlinParserListener) ExitDirectlyAssignableExpression(ctx *DirectlyAssignableExpressionContext) { +} + +// EnterParenthesizedDirectlyAssignableExpression is called when production parenthesizedDirectlyAssignableExpression is entered. +func (s *BaseKotlinParserListener) EnterParenthesizedDirectlyAssignableExpression(ctx *ParenthesizedDirectlyAssignableExpressionContext) { +} + +// ExitParenthesizedDirectlyAssignableExpression is called when production parenthesizedDirectlyAssignableExpression is exited. +func (s *BaseKotlinParserListener) ExitParenthesizedDirectlyAssignableExpression(ctx *ParenthesizedDirectlyAssignableExpressionContext) { +} + +// EnterAssignableExpression is called when production assignableExpression is entered. +func (s *BaseKotlinParserListener) EnterAssignableExpression(ctx *AssignableExpressionContext) {} + +// ExitAssignableExpression is called when production assignableExpression is exited. +func (s *BaseKotlinParserListener) ExitAssignableExpression(ctx *AssignableExpressionContext) {} + +// EnterParenthesizedAssignableExpression is called when production parenthesizedAssignableExpression is entered. +func (s *BaseKotlinParserListener) EnterParenthesizedAssignableExpression(ctx *ParenthesizedAssignableExpressionContext) { +} + +// ExitParenthesizedAssignableExpression is called when production parenthesizedAssignableExpression is exited. +func (s *BaseKotlinParserListener) ExitParenthesizedAssignableExpression(ctx *ParenthesizedAssignableExpressionContext) { +} + +// EnterAssignableSuffix is called when production assignableSuffix is entered. +func (s *BaseKotlinParserListener) EnterAssignableSuffix(ctx *AssignableSuffixContext) {} + +// ExitAssignableSuffix is called when production assignableSuffix is exited. +func (s *BaseKotlinParserListener) ExitAssignableSuffix(ctx *AssignableSuffixContext) {} + +// EnterIndexingSuffix is called when production indexingSuffix is entered. +func (s *BaseKotlinParserListener) EnterIndexingSuffix(ctx *IndexingSuffixContext) {} + +// ExitIndexingSuffix is called when production indexingSuffix is exited. +func (s *BaseKotlinParserListener) ExitIndexingSuffix(ctx *IndexingSuffixContext) {} + +// EnterNavigationSuffix is called when production navigationSuffix is entered. +func (s *BaseKotlinParserListener) EnterNavigationSuffix(ctx *NavigationSuffixContext) {} + +// ExitNavigationSuffix is called when production navigationSuffix is exited. +func (s *BaseKotlinParserListener) ExitNavigationSuffix(ctx *NavigationSuffixContext) {} + +// EnterCallSuffix is called when production callSuffix is entered. +func (s *BaseKotlinParserListener) EnterCallSuffix(ctx *CallSuffixContext) {} + +// ExitCallSuffix is called when production callSuffix is exited. +func (s *BaseKotlinParserListener) ExitCallSuffix(ctx *CallSuffixContext) {} + +// EnterAnnotatedLambda is called when production annotatedLambda is entered. +func (s *BaseKotlinParserListener) EnterAnnotatedLambda(ctx *AnnotatedLambdaContext) {} + +// ExitAnnotatedLambda is called when production annotatedLambda is exited. +func (s *BaseKotlinParserListener) ExitAnnotatedLambda(ctx *AnnotatedLambdaContext) {} + +// EnterTypeArguments is called when production typeArguments is entered. +func (s *BaseKotlinParserListener) EnterTypeArguments(ctx *TypeArgumentsContext) {} + +// ExitTypeArguments is called when production typeArguments is exited. +func (s *BaseKotlinParserListener) ExitTypeArguments(ctx *TypeArgumentsContext) {} + +// EnterValueArguments is called when production valueArguments is entered. +func (s *BaseKotlinParserListener) EnterValueArguments(ctx *ValueArgumentsContext) {} + +// ExitValueArguments is called when production valueArguments is exited. +func (s *BaseKotlinParserListener) ExitValueArguments(ctx *ValueArgumentsContext) {} + +// EnterValueArgument is called when production valueArgument is entered. +func (s *BaseKotlinParserListener) EnterValueArgument(ctx *ValueArgumentContext) {} + +// ExitValueArgument is called when production valueArgument is exited. +func (s *BaseKotlinParserListener) ExitValueArgument(ctx *ValueArgumentContext) {} + +// EnterPrimaryExpression is called when production primaryExpression is entered. +func (s *BaseKotlinParserListener) EnterPrimaryExpression(ctx *PrimaryExpressionContext) {} + +// ExitPrimaryExpression is called when production primaryExpression is exited. +func (s *BaseKotlinParserListener) ExitPrimaryExpression(ctx *PrimaryExpressionContext) {} + +// EnterParenthesizedExpression is called when production parenthesizedExpression is entered. +func (s *BaseKotlinParserListener) EnterParenthesizedExpression(ctx *ParenthesizedExpressionContext) { +} + +// ExitParenthesizedExpression is called when production parenthesizedExpression is exited. +func (s *BaseKotlinParserListener) ExitParenthesizedExpression(ctx *ParenthesizedExpressionContext) {} + +// EnterCollectionLiteral is called when production collectionLiteral is entered. +func (s *BaseKotlinParserListener) EnterCollectionLiteral(ctx *CollectionLiteralContext) {} + +// ExitCollectionLiteral is called when production collectionLiteral is exited. +func (s *BaseKotlinParserListener) ExitCollectionLiteral(ctx *CollectionLiteralContext) {} + +// EnterLiteralConstant is called when production literalConstant is entered. +func (s *BaseKotlinParserListener) EnterLiteralConstant(ctx *LiteralConstantContext) {} + +// ExitLiteralConstant is called when production literalConstant is exited. +func (s *BaseKotlinParserListener) ExitLiteralConstant(ctx *LiteralConstantContext) {} + +// EnterStringLiteral is called when production stringLiteral is entered. +func (s *BaseKotlinParserListener) EnterStringLiteral(ctx *StringLiteralContext) {} + +// ExitStringLiteral is called when production stringLiteral is exited. +func (s *BaseKotlinParserListener) ExitStringLiteral(ctx *StringLiteralContext) {} + +// EnterLineStringLiteral is called when production lineStringLiteral is entered. +func (s *BaseKotlinParserListener) EnterLineStringLiteral(ctx *LineStringLiteralContext) {} + +// ExitLineStringLiteral is called when production lineStringLiteral is exited. +func (s *BaseKotlinParserListener) ExitLineStringLiteral(ctx *LineStringLiteralContext) {} + +// EnterMultiLineStringLiteral is called when production multiLineStringLiteral is entered. +func (s *BaseKotlinParserListener) EnterMultiLineStringLiteral(ctx *MultiLineStringLiteralContext) {} + +// ExitMultiLineStringLiteral is called when production multiLineStringLiteral is exited. +func (s *BaseKotlinParserListener) ExitMultiLineStringLiteral(ctx *MultiLineStringLiteralContext) {} + +// EnterLineStringContent is called when production lineStringContent is entered. +func (s *BaseKotlinParserListener) EnterLineStringContent(ctx *LineStringContentContext) {} + +// ExitLineStringContent is called when production lineStringContent is exited. +func (s *BaseKotlinParserListener) ExitLineStringContent(ctx *LineStringContentContext) {} + +// EnterLineStringExpression is called when production lineStringExpression is entered. +func (s *BaseKotlinParserListener) EnterLineStringExpression(ctx *LineStringExpressionContext) {} + +// ExitLineStringExpression is called when production lineStringExpression is exited. +func (s *BaseKotlinParserListener) ExitLineStringExpression(ctx *LineStringExpressionContext) {} + +// EnterMultiLineStringContent is called when production multiLineStringContent is entered. +func (s *BaseKotlinParserListener) EnterMultiLineStringContent(ctx *MultiLineStringContentContext) {} + +// ExitMultiLineStringContent is called when production multiLineStringContent is exited. +func (s *BaseKotlinParserListener) ExitMultiLineStringContent(ctx *MultiLineStringContentContext) {} + +// EnterMultiLineStringExpression is called when production multiLineStringExpression is entered. +func (s *BaseKotlinParserListener) EnterMultiLineStringExpression(ctx *MultiLineStringExpressionContext) { +} + +// ExitMultiLineStringExpression is called when production multiLineStringExpression is exited. +func (s *BaseKotlinParserListener) ExitMultiLineStringExpression(ctx *MultiLineStringExpressionContext) { +} + +// EnterLambdaLiteral is called when production lambdaLiteral is entered. +func (s *BaseKotlinParserListener) EnterLambdaLiteral(ctx *LambdaLiteralContext) {} + +// ExitLambdaLiteral is called when production lambdaLiteral is exited. +func (s *BaseKotlinParserListener) ExitLambdaLiteral(ctx *LambdaLiteralContext) {} + +// EnterLambdaParameters is called when production lambdaParameters is entered. +func (s *BaseKotlinParserListener) EnterLambdaParameters(ctx *LambdaParametersContext) {} + +// ExitLambdaParameters is called when production lambdaParameters is exited. +func (s *BaseKotlinParserListener) ExitLambdaParameters(ctx *LambdaParametersContext) {} + +// EnterLambdaParameter is called when production lambdaParameter is entered. +func (s *BaseKotlinParserListener) EnterLambdaParameter(ctx *LambdaParameterContext) {} + +// ExitLambdaParameter is called when production lambdaParameter is exited. +func (s *BaseKotlinParserListener) ExitLambdaParameter(ctx *LambdaParameterContext) {} + +// EnterAnonymousFunction is called when production anonymousFunction is entered. +func (s *BaseKotlinParserListener) EnterAnonymousFunction(ctx *AnonymousFunctionContext) {} + +// ExitAnonymousFunction is called when production anonymousFunction is exited. +func (s *BaseKotlinParserListener) ExitAnonymousFunction(ctx *AnonymousFunctionContext) {} + +// EnterFunctionLiteral is called when production functionLiteral is entered. +func (s *BaseKotlinParserListener) EnterFunctionLiteral(ctx *FunctionLiteralContext) {} + +// ExitFunctionLiteral is called when production functionLiteral is exited. +func (s *BaseKotlinParserListener) ExitFunctionLiteral(ctx *FunctionLiteralContext) {} + +// EnterObjectLiteral is called when production objectLiteral is entered. +func (s *BaseKotlinParserListener) EnterObjectLiteral(ctx *ObjectLiteralContext) {} + +// ExitObjectLiteral is called when production objectLiteral is exited. +func (s *BaseKotlinParserListener) ExitObjectLiteral(ctx *ObjectLiteralContext) {} + +// EnterThisExpression is called when production thisExpression is entered. +func (s *BaseKotlinParserListener) EnterThisExpression(ctx *ThisExpressionContext) {} + +// ExitThisExpression is called when production thisExpression is exited. +func (s *BaseKotlinParserListener) ExitThisExpression(ctx *ThisExpressionContext) {} + +// EnterSuperExpression is called when production superExpression is entered. +func (s *BaseKotlinParserListener) EnterSuperExpression(ctx *SuperExpressionContext) {} + +// ExitSuperExpression is called when production superExpression is exited. +func (s *BaseKotlinParserListener) ExitSuperExpression(ctx *SuperExpressionContext) {} + +// EnterIfExpression is called when production ifExpression is entered. +func (s *BaseKotlinParserListener) EnterIfExpression(ctx *IfExpressionContext) {} + +// ExitIfExpression is called when production ifExpression is exited. +func (s *BaseKotlinParserListener) ExitIfExpression(ctx *IfExpressionContext) {} + +// EnterWhenSubject is called when production whenSubject is entered. +func (s *BaseKotlinParserListener) EnterWhenSubject(ctx *WhenSubjectContext) {} + +// ExitWhenSubject is called when production whenSubject is exited. +func (s *BaseKotlinParserListener) ExitWhenSubject(ctx *WhenSubjectContext) {} + +// EnterWhenExpression is called when production whenExpression is entered. +func (s *BaseKotlinParserListener) EnterWhenExpression(ctx *WhenExpressionContext) {} + +// ExitWhenExpression is called when production whenExpression is exited. +func (s *BaseKotlinParserListener) ExitWhenExpression(ctx *WhenExpressionContext) {} + +// EnterWhenEntry is called when production whenEntry is entered. +func (s *BaseKotlinParserListener) EnterWhenEntry(ctx *WhenEntryContext) {} + +// ExitWhenEntry is called when production whenEntry is exited. +func (s *BaseKotlinParserListener) ExitWhenEntry(ctx *WhenEntryContext) {} + +// EnterWhenCondition is called when production whenCondition is entered. +func (s *BaseKotlinParserListener) EnterWhenCondition(ctx *WhenConditionContext) {} + +// ExitWhenCondition is called when production whenCondition is exited. +func (s *BaseKotlinParserListener) ExitWhenCondition(ctx *WhenConditionContext) {} + +// EnterRangeTest is called when production rangeTest is entered. +func (s *BaseKotlinParserListener) EnterRangeTest(ctx *RangeTestContext) {} + +// ExitRangeTest is called when production rangeTest is exited. +func (s *BaseKotlinParserListener) ExitRangeTest(ctx *RangeTestContext) {} + +// EnterTypeTest is called when production typeTest is entered. +func (s *BaseKotlinParserListener) EnterTypeTest(ctx *TypeTestContext) {} + +// ExitTypeTest is called when production typeTest is exited. +func (s *BaseKotlinParserListener) ExitTypeTest(ctx *TypeTestContext) {} + +// EnterTryExpression is called when production tryExpression is entered. +func (s *BaseKotlinParserListener) EnterTryExpression(ctx *TryExpressionContext) {} + +// ExitTryExpression is called when production tryExpression is exited. +func (s *BaseKotlinParserListener) ExitTryExpression(ctx *TryExpressionContext) {} + +// EnterCatchBlock is called when production catchBlock is entered. +func (s *BaseKotlinParserListener) EnterCatchBlock(ctx *CatchBlockContext) {} + +// ExitCatchBlock is called when production catchBlock is exited. +func (s *BaseKotlinParserListener) ExitCatchBlock(ctx *CatchBlockContext) {} + +// EnterFinallyBlock is called when production finallyBlock is entered. +func (s *BaseKotlinParserListener) EnterFinallyBlock(ctx *FinallyBlockContext) {} + +// ExitFinallyBlock is called when production finallyBlock is exited. +func (s *BaseKotlinParserListener) ExitFinallyBlock(ctx *FinallyBlockContext) {} + +// EnterJumpExpression is called when production jumpExpression is entered. +func (s *BaseKotlinParserListener) EnterJumpExpression(ctx *JumpExpressionContext) {} + +// ExitJumpExpression is called when production jumpExpression is exited. +func (s *BaseKotlinParserListener) ExitJumpExpression(ctx *JumpExpressionContext) {} + +// EnterCallableReference is called when production callableReference is entered. +func (s *BaseKotlinParserListener) EnterCallableReference(ctx *CallableReferenceContext) {} + +// ExitCallableReference is called when production callableReference is exited. +func (s *BaseKotlinParserListener) ExitCallableReference(ctx *CallableReferenceContext) {} + +// EnterAssignmentAndOperator is called when production assignmentAndOperator is entered. +func (s *BaseKotlinParserListener) EnterAssignmentAndOperator(ctx *AssignmentAndOperatorContext) {} + +// ExitAssignmentAndOperator is called when production assignmentAndOperator is exited. +func (s *BaseKotlinParserListener) ExitAssignmentAndOperator(ctx *AssignmentAndOperatorContext) {} + +// EnterEqualityOperator is called when production equalityOperator is entered. +func (s *BaseKotlinParserListener) EnterEqualityOperator(ctx *EqualityOperatorContext) {} + +// ExitEqualityOperator is called when production equalityOperator is exited. +func (s *BaseKotlinParserListener) ExitEqualityOperator(ctx *EqualityOperatorContext) {} + +// EnterComparisonOperator is called when production comparisonOperator is entered. +func (s *BaseKotlinParserListener) EnterComparisonOperator(ctx *ComparisonOperatorContext) {} + +// ExitComparisonOperator is called when production comparisonOperator is exited. +func (s *BaseKotlinParserListener) ExitComparisonOperator(ctx *ComparisonOperatorContext) {} + +// EnterInOperator is called when production inOperator is entered. +func (s *BaseKotlinParserListener) EnterInOperator(ctx *InOperatorContext) {} + +// ExitInOperator is called when production inOperator is exited. +func (s *BaseKotlinParserListener) ExitInOperator(ctx *InOperatorContext) {} + +// EnterIsOperator is called when production isOperator is entered. +func (s *BaseKotlinParserListener) EnterIsOperator(ctx *IsOperatorContext) {} + +// ExitIsOperator is called when production isOperator is exited. +func (s *BaseKotlinParserListener) ExitIsOperator(ctx *IsOperatorContext) {} + +// EnterAdditiveOperator is called when production additiveOperator is entered. +func (s *BaseKotlinParserListener) EnterAdditiveOperator(ctx *AdditiveOperatorContext) {} + +// ExitAdditiveOperator is called when production additiveOperator is exited. +func (s *BaseKotlinParserListener) ExitAdditiveOperator(ctx *AdditiveOperatorContext) {} + +// EnterMultiplicativeOperator is called when production multiplicativeOperator is entered. +func (s *BaseKotlinParserListener) EnterMultiplicativeOperator(ctx *MultiplicativeOperatorContext) {} + +// ExitMultiplicativeOperator is called when production multiplicativeOperator is exited. +func (s *BaseKotlinParserListener) ExitMultiplicativeOperator(ctx *MultiplicativeOperatorContext) {} + +// EnterAsOperator is called when production asOperator is entered. +func (s *BaseKotlinParserListener) EnterAsOperator(ctx *AsOperatorContext) {} + +// ExitAsOperator is called when production asOperator is exited. +func (s *BaseKotlinParserListener) ExitAsOperator(ctx *AsOperatorContext) {} + +// EnterPrefixUnaryOperator is called when production prefixUnaryOperator is entered. +func (s *BaseKotlinParserListener) EnterPrefixUnaryOperator(ctx *PrefixUnaryOperatorContext) {} + +// ExitPrefixUnaryOperator is called when production prefixUnaryOperator is exited. +func (s *BaseKotlinParserListener) ExitPrefixUnaryOperator(ctx *PrefixUnaryOperatorContext) {} + +// EnterPostfixUnaryOperator is called when production postfixUnaryOperator is entered. +func (s *BaseKotlinParserListener) EnterPostfixUnaryOperator(ctx *PostfixUnaryOperatorContext) {} + +// ExitPostfixUnaryOperator is called when production postfixUnaryOperator is exited. +func (s *BaseKotlinParserListener) ExitPostfixUnaryOperator(ctx *PostfixUnaryOperatorContext) {} + +// EnterExcl is called when production excl is entered. +func (s *BaseKotlinParserListener) EnterExcl(ctx *ExclContext) {} + +// ExitExcl is called when production excl is exited. +func (s *BaseKotlinParserListener) ExitExcl(ctx *ExclContext) {} + +// EnterMemberAccessOperator is called when production memberAccessOperator is entered. +func (s *BaseKotlinParserListener) EnterMemberAccessOperator(ctx *MemberAccessOperatorContext) {} + +// ExitMemberAccessOperator is called when production memberAccessOperator is exited. +func (s *BaseKotlinParserListener) ExitMemberAccessOperator(ctx *MemberAccessOperatorContext) {} + +// EnterSafeNav is called when production safeNav is entered. +func (s *BaseKotlinParserListener) EnterSafeNav(ctx *SafeNavContext) {} + +// ExitSafeNav is called when production safeNav is exited. +func (s *BaseKotlinParserListener) ExitSafeNav(ctx *SafeNavContext) {} + +// EnterModifiers is called when production modifiers is entered. +func (s *BaseKotlinParserListener) EnterModifiers(ctx *ModifiersContext) {} + +// ExitModifiers is called when production modifiers is exited. +func (s *BaseKotlinParserListener) ExitModifiers(ctx *ModifiersContext) {} + +// EnterParameterModifiers is called when production parameterModifiers is entered. +func (s *BaseKotlinParserListener) EnterParameterModifiers(ctx *ParameterModifiersContext) {} + +// ExitParameterModifiers is called when production parameterModifiers is exited. +func (s *BaseKotlinParserListener) ExitParameterModifiers(ctx *ParameterModifiersContext) {} + +// EnterModifier is called when production modifier is entered. +func (s *BaseKotlinParserListener) EnterModifier(ctx *ModifierContext) {} + +// ExitModifier is called when production modifier is exited. +func (s *BaseKotlinParserListener) ExitModifier(ctx *ModifierContext) {} + +// EnterTypeModifiers is called when production typeModifiers is entered. +func (s *BaseKotlinParserListener) EnterTypeModifiers(ctx *TypeModifiersContext) {} + +// ExitTypeModifiers is called when production typeModifiers is exited. +func (s *BaseKotlinParserListener) ExitTypeModifiers(ctx *TypeModifiersContext) {} + +// EnterTypeModifier is called when production typeModifier is entered. +func (s *BaseKotlinParserListener) EnterTypeModifier(ctx *TypeModifierContext) {} + +// ExitTypeModifier is called when production typeModifier is exited. +func (s *BaseKotlinParserListener) ExitTypeModifier(ctx *TypeModifierContext) {} + +// EnterClassModifier is called when production classModifier is entered. +func (s *BaseKotlinParserListener) EnterClassModifier(ctx *ClassModifierContext) {} + +// ExitClassModifier is called when production classModifier is exited. +func (s *BaseKotlinParserListener) ExitClassModifier(ctx *ClassModifierContext) {} + +// EnterMemberModifier is called when production memberModifier is entered. +func (s *BaseKotlinParserListener) EnterMemberModifier(ctx *MemberModifierContext) {} + +// ExitMemberModifier is called when production memberModifier is exited. +func (s *BaseKotlinParserListener) ExitMemberModifier(ctx *MemberModifierContext) {} + +// EnterVisibilityModifier is called when production visibilityModifier is entered. +func (s *BaseKotlinParserListener) EnterVisibilityModifier(ctx *VisibilityModifierContext) {} + +// ExitVisibilityModifier is called when production visibilityModifier is exited. +func (s *BaseKotlinParserListener) ExitVisibilityModifier(ctx *VisibilityModifierContext) {} + +// EnterVarianceModifier is called when production varianceModifier is entered. +func (s *BaseKotlinParserListener) EnterVarianceModifier(ctx *VarianceModifierContext) {} + +// ExitVarianceModifier is called when production varianceModifier is exited. +func (s *BaseKotlinParserListener) ExitVarianceModifier(ctx *VarianceModifierContext) {} + +// EnterTypeParameterModifiers is called when production typeParameterModifiers is entered. +func (s *BaseKotlinParserListener) EnterTypeParameterModifiers(ctx *TypeParameterModifiersContext) {} + +// ExitTypeParameterModifiers is called when production typeParameterModifiers is exited. +func (s *BaseKotlinParserListener) ExitTypeParameterModifiers(ctx *TypeParameterModifiersContext) {} + +// EnterTypeParameterModifier is called when production typeParameterModifier is entered. +func (s *BaseKotlinParserListener) EnterTypeParameterModifier(ctx *TypeParameterModifierContext) {} + +// ExitTypeParameterModifier is called when production typeParameterModifier is exited. +func (s *BaseKotlinParserListener) ExitTypeParameterModifier(ctx *TypeParameterModifierContext) {} + +// EnterFunctionModifier is called when production functionModifier is entered. +func (s *BaseKotlinParserListener) EnterFunctionModifier(ctx *FunctionModifierContext) {} + +// ExitFunctionModifier is called when production functionModifier is exited. +func (s *BaseKotlinParserListener) ExitFunctionModifier(ctx *FunctionModifierContext) {} + +// EnterPropertyModifier is called when production propertyModifier is entered. +func (s *BaseKotlinParserListener) EnterPropertyModifier(ctx *PropertyModifierContext) {} + +// ExitPropertyModifier is called when production propertyModifier is exited. +func (s *BaseKotlinParserListener) ExitPropertyModifier(ctx *PropertyModifierContext) {} + +// EnterInheritanceModifier is called when production inheritanceModifier is entered. +func (s *BaseKotlinParserListener) EnterInheritanceModifier(ctx *InheritanceModifierContext) {} + +// ExitInheritanceModifier is called when production inheritanceModifier is exited. +func (s *BaseKotlinParserListener) ExitInheritanceModifier(ctx *InheritanceModifierContext) {} + +// EnterParameterModifier is called when production parameterModifier is entered. +func (s *BaseKotlinParserListener) EnterParameterModifier(ctx *ParameterModifierContext) {} + +// ExitParameterModifier is called when production parameterModifier is exited. +func (s *BaseKotlinParserListener) ExitParameterModifier(ctx *ParameterModifierContext) {} + +// EnterReificationModifier is called when production reificationModifier is entered. +func (s *BaseKotlinParserListener) EnterReificationModifier(ctx *ReificationModifierContext) {} + +// ExitReificationModifier is called when production reificationModifier is exited. +func (s *BaseKotlinParserListener) ExitReificationModifier(ctx *ReificationModifierContext) {} + +// EnterPlatformModifier is called when production platformModifier is entered. +func (s *BaseKotlinParserListener) EnterPlatformModifier(ctx *PlatformModifierContext) {} + +// ExitPlatformModifier is called when production platformModifier is exited. +func (s *BaseKotlinParserListener) ExitPlatformModifier(ctx *PlatformModifierContext) {} + +// EnterAnnotation is called when production annotation is entered. +func (s *BaseKotlinParserListener) EnterAnnotation(ctx *AnnotationContext) {} + +// ExitAnnotation is called when production annotation is exited. +func (s *BaseKotlinParserListener) ExitAnnotation(ctx *AnnotationContext) {} + +// EnterSingleAnnotation is called when production singleAnnotation is entered. +func (s *BaseKotlinParserListener) EnterSingleAnnotation(ctx *SingleAnnotationContext) {} + +// ExitSingleAnnotation is called when production singleAnnotation is exited. +func (s *BaseKotlinParserListener) ExitSingleAnnotation(ctx *SingleAnnotationContext) {} + +// EnterMultiAnnotation is called when production multiAnnotation is entered. +func (s *BaseKotlinParserListener) EnterMultiAnnotation(ctx *MultiAnnotationContext) {} + +// ExitMultiAnnotation is called when production multiAnnotation is exited. +func (s *BaseKotlinParserListener) ExitMultiAnnotation(ctx *MultiAnnotationContext) {} + +// EnterAnnotationUseSiteTarget is called when production annotationUseSiteTarget is entered. +func (s *BaseKotlinParserListener) EnterAnnotationUseSiteTarget(ctx *AnnotationUseSiteTargetContext) { +} + +// ExitAnnotationUseSiteTarget is called when production annotationUseSiteTarget is exited. +func (s *BaseKotlinParserListener) ExitAnnotationUseSiteTarget(ctx *AnnotationUseSiteTargetContext) {} + +// EnterUnescapedAnnotation is called when production unescapedAnnotation is entered. +func (s *BaseKotlinParserListener) EnterUnescapedAnnotation(ctx *UnescapedAnnotationContext) {} + +// ExitUnescapedAnnotation is called when production unescapedAnnotation is exited. +func (s *BaseKotlinParserListener) ExitUnescapedAnnotation(ctx *UnescapedAnnotationContext) {} + +// EnterSimpleIdentifier is called when production simpleIdentifier is entered. +func (s *BaseKotlinParserListener) EnterSimpleIdentifier(ctx *SimpleIdentifierContext) {} + +// ExitSimpleIdentifier is called when production simpleIdentifier is exited. +func (s *BaseKotlinParserListener) ExitSimpleIdentifier(ctx *SimpleIdentifierContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BaseKotlinParserListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BaseKotlinParserListener) ExitIdentifier(ctx *IdentifierContext) {} diff --git a/lib/archer/kotlin_parser/kotlinparser_listener.go b/lib/archer/kotlin_parser/kotlinparser_listener.go new file mode 100644 index 0000000..2c6276c --- /dev/null +++ b/lib/archer/kotlin_parser/kotlinparser_listener.go @@ -0,0 +1,1053 @@ +// Code generated from java-escape by ANTLR 4.11.1. DO NOT EDIT. + +package kotlin_parser // KotlinParser +import "github.com/antlr/antlr4/runtime/Go/antlr/v4" + +// KotlinParserListener is a complete listener for a parse tree produced by KotlinParser. +type KotlinParserListener interface { + antlr.ParseTreeListener + + // EnterKotlinFile is called when entering the kotlinFile production. + EnterKotlinFile(c *KotlinFileContext) + + // EnterScript is called when entering the script production. + EnterScript(c *ScriptContext) + + // EnterShebangLine is called when entering the shebangLine production. + EnterShebangLine(c *ShebangLineContext) + + // EnterFileAnnotation is called when entering the fileAnnotation production. + EnterFileAnnotation(c *FileAnnotationContext) + + // EnterPackageHeader is called when entering the packageHeader production. + EnterPackageHeader(c *PackageHeaderContext) + + // EnterImportList is called when entering the importList production. + EnterImportList(c *ImportListContext) + + // EnterImportHeader is called when entering the importHeader production. + EnterImportHeader(c *ImportHeaderContext) + + // EnterImportAlias is called when entering the importAlias production. + EnterImportAlias(c *ImportAliasContext) + + // EnterTopLevelObject is called when entering the topLevelObject production. + EnterTopLevelObject(c *TopLevelObjectContext) + + // EnterTypeAlias is called when entering the typeAlias production. + EnterTypeAlias(c *TypeAliasContext) + + // EnterDeclaration is called when entering the declaration production. + EnterDeclaration(c *DeclarationContext) + + // EnterClassDeclaration is called when entering the classDeclaration production. + EnterClassDeclaration(c *ClassDeclarationContext) + + // EnterPrimaryConstructor is called when entering the primaryConstructor production. + EnterPrimaryConstructor(c *PrimaryConstructorContext) + + // EnterClassBody is called when entering the classBody production. + EnterClassBody(c *ClassBodyContext) + + // EnterClassParameters is called when entering the classParameters production. + EnterClassParameters(c *ClassParametersContext) + + // EnterClassParameter is called when entering the classParameter production. + EnterClassParameter(c *ClassParameterContext) + + // EnterDelegationSpecifiers is called when entering the delegationSpecifiers production. + EnterDelegationSpecifiers(c *DelegationSpecifiersContext) + + // EnterDelegationSpecifier is called when entering the delegationSpecifier production. + EnterDelegationSpecifier(c *DelegationSpecifierContext) + + // EnterConstructorInvocation is called when entering the constructorInvocation production. + EnterConstructorInvocation(c *ConstructorInvocationContext) + + // EnterAnnotatedDelegationSpecifier is called when entering the annotatedDelegationSpecifier production. + EnterAnnotatedDelegationSpecifier(c *AnnotatedDelegationSpecifierContext) + + // EnterExplicitDelegation is called when entering the explicitDelegation production. + EnterExplicitDelegation(c *ExplicitDelegationContext) + + // EnterTypeParameters is called when entering the typeParameters production. + EnterTypeParameters(c *TypeParametersContext) + + // EnterTypeParameter is called when entering the typeParameter production. + EnterTypeParameter(c *TypeParameterContext) + + // EnterTypeConstraints is called when entering the typeConstraints production. + EnterTypeConstraints(c *TypeConstraintsContext) + + // EnterTypeConstraint is called when entering the typeConstraint production. + EnterTypeConstraint(c *TypeConstraintContext) + + // EnterClassMemberDeclarations is called when entering the classMemberDeclarations production. + EnterClassMemberDeclarations(c *ClassMemberDeclarationsContext) + + // EnterClassMemberDeclaration is called when entering the classMemberDeclaration production. + EnterClassMemberDeclaration(c *ClassMemberDeclarationContext) + + // EnterAnonymousInitializer is called when entering the anonymousInitializer production. + EnterAnonymousInitializer(c *AnonymousInitializerContext) + + // EnterCompanionObject is called when entering the companionObject production. + EnterCompanionObject(c *CompanionObjectContext) + + // EnterFunctionValueParameters is called when entering the functionValueParameters production. + EnterFunctionValueParameters(c *FunctionValueParametersContext) + + // EnterFunctionValueParameter is called when entering the functionValueParameter production. + EnterFunctionValueParameter(c *FunctionValueParameterContext) + + // EnterFunctionDeclaration is called when entering the functionDeclaration production. + EnterFunctionDeclaration(c *FunctionDeclarationContext) + + // EnterFunctionBody is called when entering the functionBody production. + EnterFunctionBody(c *FunctionBodyContext) + + // EnterVariableDeclaration is called when entering the variableDeclaration production. + EnterVariableDeclaration(c *VariableDeclarationContext) + + // EnterMultiVariableDeclaration is called when entering the multiVariableDeclaration production. + EnterMultiVariableDeclaration(c *MultiVariableDeclarationContext) + + // EnterPropertyDeclaration is called when entering the propertyDeclaration production. + EnterPropertyDeclaration(c *PropertyDeclarationContext) + + // EnterPropertyDelegate is called when entering the propertyDelegate production. + EnterPropertyDelegate(c *PropertyDelegateContext) + + // EnterGetter is called when entering the getter production. + EnterGetter(c *GetterContext) + + // EnterSetter is called when entering the setter production. + EnterSetter(c *SetterContext) + + // EnterParametersWithOptionalType is called when entering the parametersWithOptionalType production. + EnterParametersWithOptionalType(c *ParametersWithOptionalTypeContext) + + // EnterFunctionValueParameterWithOptionalType is called when entering the functionValueParameterWithOptionalType production. + EnterFunctionValueParameterWithOptionalType(c *FunctionValueParameterWithOptionalTypeContext) + + // EnterParameterWithOptionalType is called when entering the parameterWithOptionalType production. + EnterParameterWithOptionalType(c *ParameterWithOptionalTypeContext) + + // EnterParameter is called when entering the parameter production. + EnterParameter(c *ParameterContext) + + // EnterObjectDeclaration is called when entering the objectDeclaration production. + EnterObjectDeclaration(c *ObjectDeclarationContext) + + // EnterSecondaryConstructor is called when entering the secondaryConstructor production. + EnterSecondaryConstructor(c *SecondaryConstructorContext) + + // EnterConstructorDelegationCall is called when entering the constructorDelegationCall production. + EnterConstructorDelegationCall(c *ConstructorDelegationCallContext) + + // EnterEnumClassBody is called when entering the enumClassBody production. + EnterEnumClassBody(c *EnumClassBodyContext) + + // EnterEnumEntries is called when entering the enumEntries production. + EnterEnumEntries(c *EnumEntriesContext) + + // EnterEnumEntry is called when entering the enumEntry production. + EnterEnumEntry(c *EnumEntryContext) + + // EnterType is called when entering the type production. + EnterType(c *TypeContext) + + // EnterTypeReference is called when entering the typeReference production. + EnterTypeReference(c *TypeReferenceContext) + + // EnterNullableType is called when entering the nullableType production. + EnterNullableType(c *NullableTypeContext) + + // EnterQuest is called when entering the quest production. + EnterQuest(c *QuestContext) + + // EnterUserType is called when entering the userType production. + EnterUserType(c *UserTypeContext) + + // EnterSimpleUserType is called when entering the simpleUserType production. + EnterSimpleUserType(c *SimpleUserTypeContext) + + // EnterTypeProjection is called when entering the typeProjection production. + EnterTypeProjection(c *TypeProjectionContext) + + // EnterTypeProjectionModifiers is called when entering the typeProjectionModifiers production. + EnterTypeProjectionModifiers(c *TypeProjectionModifiersContext) + + // EnterTypeProjectionModifier is called when entering the typeProjectionModifier production. + EnterTypeProjectionModifier(c *TypeProjectionModifierContext) + + // EnterFunctionType is called when entering the functionType production. + EnterFunctionType(c *FunctionTypeContext) + + // EnterFunctionTypeParameters is called when entering the functionTypeParameters production. + EnterFunctionTypeParameters(c *FunctionTypeParametersContext) + + // EnterParenthesizedType is called when entering the parenthesizedType production. + EnterParenthesizedType(c *ParenthesizedTypeContext) + + // EnterReceiverType is called when entering the receiverType production. + EnterReceiverType(c *ReceiverTypeContext) + + // EnterParenthesizedUserType is called when entering the parenthesizedUserType production. + EnterParenthesizedUserType(c *ParenthesizedUserTypeContext) + + // EnterDefinitelyNonNullableType is called when entering the definitelyNonNullableType production. + EnterDefinitelyNonNullableType(c *DefinitelyNonNullableTypeContext) + + // EnterStatements is called when entering the statements production. + EnterStatements(c *StatementsContext) + + // EnterStatement is called when entering the statement production. + EnterStatement(c *StatementContext) + + // EnterLabel is called when entering the label production. + EnterLabel(c *LabelContext) + + // EnterControlStructureBody is called when entering the controlStructureBody production. + EnterControlStructureBody(c *ControlStructureBodyContext) + + // EnterBlock is called when entering the block production. + EnterBlock(c *BlockContext) + + // EnterLoopStatement is called when entering the loopStatement production. + EnterLoopStatement(c *LoopStatementContext) + + // EnterForStatement is called when entering the forStatement production. + EnterForStatement(c *ForStatementContext) + + // EnterWhileStatement is called when entering the whileStatement production. + EnterWhileStatement(c *WhileStatementContext) + + // EnterDoWhileStatement is called when entering the doWhileStatement production. + EnterDoWhileStatement(c *DoWhileStatementContext) + + // EnterAssignment is called when entering the assignment production. + EnterAssignment(c *AssignmentContext) + + // EnterSemi is called when entering the semi production. + EnterSemi(c *SemiContext) + + // EnterSemis is called when entering the semis production. + EnterSemis(c *SemisContext) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterDisjunction is called when entering the disjunction production. + EnterDisjunction(c *DisjunctionContext) + + // EnterConjunction is called when entering the conjunction production. + EnterConjunction(c *ConjunctionContext) + + // EnterEquality is called when entering the equality production. + EnterEquality(c *EqualityContext) + + // EnterComparison is called when entering the comparison production. + EnterComparison(c *ComparisonContext) + + // EnterGenericCallLikeComparison is called when entering the genericCallLikeComparison production. + EnterGenericCallLikeComparison(c *GenericCallLikeComparisonContext) + + // EnterInfixOperation is called when entering the infixOperation production. + EnterInfixOperation(c *InfixOperationContext) + + // EnterElvisExpression is called when entering the elvisExpression production. + EnterElvisExpression(c *ElvisExpressionContext) + + // EnterElvis is called when entering the elvis production. + EnterElvis(c *ElvisContext) + + // EnterInfixFunctionCall is called when entering the infixFunctionCall production. + EnterInfixFunctionCall(c *InfixFunctionCallContext) + + // EnterRangeExpression is called when entering the rangeExpression production. + EnterRangeExpression(c *RangeExpressionContext) + + // EnterAdditiveExpression is called when entering the additiveExpression production. + EnterAdditiveExpression(c *AdditiveExpressionContext) + + // EnterMultiplicativeExpression is called when entering the multiplicativeExpression production. + EnterMultiplicativeExpression(c *MultiplicativeExpressionContext) + + // EnterAsExpression is called when entering the asExpression production. + EnterAsExpression(c *AsExpressionContext) + + // EnterPrefixUnaryExpression is called when entering the prefixUnaryExpression production. + EnterPrefixUnaryExpression(c *PrefixUnaryExpressionContext) + + // EnterUnaryPrefix is called when entering the unaryPrefix production. + EnterUnaryPrefix(c *UnaryPrefixContext) + + // EnterPostfixUnaryExpression is called when entering the postfixUnaryExpression production. + EnterPostfixUnaryExpression(c *PostfixUnaryExpressionContext) + + // EnterPostfixUnarySuffix is called when entering the postfixUnarySuffix production. + EnterPostfixUnarySuffix(c *PostfixUnarySuffixContext) + + // EnterDirectlyAssignableExpression is called when entering the directlyAssignableExpression production. + EnterDirectlyAssignableExpression(c *DirectlyAssignableExpressionContext) + + // EnterParenthesizedDirectlyAssignableExpression is called when entering the parenthesizedDirectlyAssignableExpression production. + EnterParenthesizedDirectlyAssignableExpression(c *ParenthesizedDirectlyAssignableExpressionContext) + + // EnterAssignableExpression is called when entering the assignableExpression production. + EnterAssignableExpression(c *AssignableExpressionContext) + + // EnterParenthesizedAssignableExpression is called when entering the parenthesizedAssignableExpression production. + EnterParenthesizedAssignableExpression(c *ParenthesizedAssignableExpressionContext) + + // EnterAssignableSuffix is called when entering the assignableSuffix production. + EnterAssignableSuffix(c *AssignableSuffixContext) + + // EnterIndexingSuffix is called when entering the indexingSuffix production. + EnterIndexingSuffix(c *IndexingSuffixContext) + + // EnterNavigationSuffix is called when entering the navigationSuffix production. + EnterNavigationSuffix(c *NavigationSuffixContext) + + // EnterCallSuffix is called when entering the callSuffix production. + EnterCallSuffix(c *CallSuffixContext) + + // EnterAnnotatedLambda is called when entering the annotatedLambda production. + EnterAnnotatedLambda(c *AnnotatedLambdaContext) + + // EnterTypeArguments is called when entering the typeArguments production. + EnterTypeArguments(c *TypeArgumentsContext) + + // EnterValueArguments is called when entering the valueArguments production. + EnterValueArguments(c *ValueArgumentsContext) + + // EnterValueArgument is called when entering the valueArgument production. + EnterValueArgument(c *ValueArgumentContext) + + // EnterPrimaryExpression is called when entering the primaryExpression production. + EnterPrimaryExpression(c *PrimaryExpressionContext) + + // EnterParenthesizedExpression is called when entering the parenthesizedExpression production. + EnterParenthesizedExpression(c *ParenthesizedExpressionContext) + + // EnterCollectionLiteral is called when entering the collectionLiteral production. + EnterCollectionLiteral(c *CollectionLiteralContext) + + // EnterLiteralConstant is called when entering the literalConstant production. + EnterLiteralConstant(c *LiteralConstantContext) + + // EnterStringLiteral is called when entering the stringLiteral production. + EnterStringLiteral(c *StringLiteralContext) + + // EnterLineStringLiteral is called when entering the lineStringLiteral production. + EnterLineStringLiteral(c *LineStringLiteralContext) + + // EnterMultiLineStringLiteral is called when entering the multiLineStringLiteral production. + EnterMultiLineStringLiteral(c *MultiLineStringLiteralContext) + + // EnterLineStringContent is called when entering the lineStringContent production. + EnterLineStringContent(c *LineStringContentContext) + + // EnterLineStringExpression is called when entering the lineStringExpression production. + EnterLineStringExpression(c *LineStringExpressionContext) + + // EnterMultiLineStringContent is called when entering the multiLineStringContent production. + EnterMultiLineStringContent(c *MultiLineStringContentContext) + + // EnterMultiLineStringExpression is called when entering the multiLineStringExpression production. + EnterMultiLineStringExpression(c *MultiLineStringExpressionContext) + + // EnterLambdaLiteral is called when entering the lambdaLiteral production. + EnterLambdaLiteral(c *LambdaLiteralContext) + + // EnterLambdaParameters is called when entering the lambdaParameters production. + EnterLambdaParameters(c *LambdaParametersContext) + + // EnterLambdaParameter is called when entering the lambdaParameter production. + EnterLambdaParameter(c *LambdaParameterContext) + + // EnterAnonymousFunction is called when entering the anonymousFunction production. + EnterAnonymousFunction(c *AnonymousFunctionContext) + + // EnterFunctionLiteral is called when entering the functionLiteral production. + EnterFunctionLiteral(c *FunctionLiteralContext) + + // EnterObjectLiteral is called when entering the objectLiteral production. + EnterObjectLiteral(c *ObjectLiteralContext) + + // EnterThisExpression is called when entering the thisExpression production. + EnterThisExpression(c *ThisExpressionContext) + + // EnterSuperExpression is called when entering the superExpression production. + EnterSuperExpression(c *SuperExpressionContext) + + // EnterIfExpression is called when entering the ifExpression production. + EnterIfExpression(c *IfExpressionContext) + + // EnterWhenSubject is called when entering the whenSubject production. + EnterWhenSubject(c *WhenSubjectContext) + + // EnterWhenExpression is called when entering the whenExpression production. + EnterWhenExpression(c *WhenExpressionContext) + + // EnterWhenEntry is called when entering the whenEntry production. + EnterWhenEntry(c *WhenEntryContext) + + // EnterWhenCondition is called when entering the whenCondition production. + EnterWhenCondition(c *WhenConditionContext) + + // EnterRangeTest is called when entering the rangeTest production. + EnterRangeTest(c *RangeTestContext) + + // EnterTypeTest is called when entering the typeTest production. + EnterTypeTest(c *TypeTestContext) + + // EnterTryExpression is called when entering the tryExpression production. + EnterTryExpression(c *TryExpressionContext) + + // EnterCatchBlock is called when entering the catchBlock production. + EnterCatchBlock(c *CatchBlockContext) + + // EnterFinallyBlock is called when entering the finallyBlock production. + EnterFinallyBlock(c *FinallyBlockContext) + + // EnterJumpExpression is called when entering the jumpExpression production. + EnterJumpExpression(c *JumpExpressionContext) + + // EnterCallableReference is called when entering the callableReference production. + EnterCallableReference(c *CallableReferenceContext) + + // EnterAssignmentAndOperator is called when entering the assignmentAndOperator production. + EnterAssignmentAndOperator(c *AssignmentAndOperatorContext) + + // EnterEqualityOperator is called when entering the equalityOperator production. + EnterEqualityOperator(c *EqualityOperatorContext) + + // EnterComparisonOperator is called when entering the comparisonOperator production. + EnterComparisonOperator(c *ComparisonOperatorContext) + + // EnterInOperator is called when entering the inOperator production. + EnterInOperator(c *InOperatorContext) + + // EnterIsOperator is called when entering the isOperator production. + EnterIsOperator(c *IsOperatorContext) + + // EnterAdditiveOperator is called when entering the additiveOperator production. + EnterAdditiveOperator(c *AdditiveOperatorContext) + + // EnterMultiplicativeOperator is called when entering the multiplicativeOperator production. + EnterMultiplicativeOperator(c *MultiplicativeOperatorContext) + + // EnterAsOperator is called when entering the asOperator production. + EnterAsOperator(c *AsOperatorContext) + + // EnterPrefixUnaryOperator is called when entering the prefixUnaryOperator production. + EnterPrefixUnaryOperator(c *PrefixUnaryOperatorContext) + + // EnterPostfixUnaryOperator is called when entering the postfixUnaryOperator production. + EnterPostfixUnaryOperator(c *PostfixUnaryOperatorContext) + + // EnterExcl is called when entering the excl production. + EnterExcl(c *ExclContext) + + // EnterMemberAccessOperator is called when entering the memberAccessOperator production. + EnterMemberAccessOperator(c *MemberAccessOperatorContext) + + // EnterSafeNav is called when entering the safeNav production. + EnterSafeNav(c *SafeNavContext) + + // EnterModifiers is called when entering the modifiers production. + EnterModifiers(c *ModifiersContext) + + // EnterParameterModifiers is called when entering the parameterModifiers production. + EnterParameterModifiers(c *ParameterModifiersContext) + + // EnterModifier is called when entering the modifier production. + EnterModifier(c *ModifierContext) + + // EnterTypeModifiers is called when entering the typeModifiers production. + EnterTypeModifiers(c *TypeModifiersContext) + + // EnterTypeModifier is called when entering the typeModifier production. + EnterTypeModifier(c *TypeModifierContext) + + // EnterClassModifier is called when entering the classModifier production. + EnterClassModifier(c *ClassModifierContext) + + // EnterMemberModifier is called when entering the memberModifier production. + EnterMemberModifier(c *MemberModifierContext) + + // EnterVisibilityModifier is called when entering the visibilityModifier production. + EnterVisibilityModifier(c *VisibilityModifierContext) + + // EnterVarianceModifier is called when entering the varianceModifier production. + EnterVarianceModifier(c *VarianceModifierContext) + + // EnterTypeParameterModifiers is called when entering the typeParameterModifiers production. + EnterTypeParameterModifiers(c *TypeParameterModifiersContext) + + // EnterTypeParameterModifier is called when entering the typeParameterModifier production. + EnterTypeParameterModifier(c *TypeParameterModifierContext) + + // EnterFunctionModifier is called when entering the functionModifier production. + EnterFunctionModifier(c *FunctionModifierContext) + + // EnterPropertyModifier is called when entering the propertyModifier production. + EnterPropertyModifier(c *PropertyModifierContext) + + // EnterInheritanceModifier is called when entering the inheritanceModifier production. + EnterInheritanceModifier(c *InheritanceModifierContext) + + // EnterParameterModifier is called when entering the parameterModifier production. + EnterParameterModifier(c *ParameterModifierContext) + + // EnterReificationModifier is called when entering the reificationModifier production. + EnterReificationModifier(c *ReificationModifierContext) + + // EnterPlatformModifier is called when entering the platformModifier production. + EnterPlatformModifier(c *PlatformModifierContext) + + // EnterAnnotation is called when entering the annotation production. + EnterAnnotation(c *AnnotationContext) + + // EnterSingleAnnotation is called when entering the singleAnnotation production. + EnterSingleAnnotation(c *SingleAnnotationContext) + + // EnterMultiAnnotation is called when entering the multiAnnotation production. + EnterMultiAnnotation(c *MultiAnnotationContext) + + // EnterAnnotationUseSiteTarget is called when entering the annotationUseSiteTarget production. + EnterAnnotationUseSiteTarget(c *AnnotationUseSiteTargetContext) + + // EnterUnescapedAnnotation is called when entering the unescapedAnnotation production. + EnterUnescapedAnnotation(c *UnescapedAnnotationContext) + + // EnterSimpleIdentifier is called when entering the simpleIdentifier production. + EnterSimpleIdentifier(c *SimpleIdentifierContext) + + // EnterIdentifier is called when entering the identifier production. + EnterIdentifier(c *IdentifierContext) + + // ExitKotlinFile is called when exiting the kotlinFile production. + ExitKotlinFile(c *KotlinFileContext) + + // ExitScript is called when exiting the script production. + ExitScript(c *ScriptContext) + + // ExitShebangLine is called when exiting the shebangLine production. + ExitShebangLine(c *ShebangLineContext) + + // ExitFileAnnotation is called when exiting the fileAnnotation production. + ExitFileAnnotation(c *FileAnnotationContext) + + // ExitPackageHeader is called when exiting the packageHeader production. + ExitPackageHeader(c *PackageHeaderContext) + + // ExitImportList is called when exiting the importList production. + ExitImportList(c *ImportListContext) + + // ExitImportHeader is called when exiting the importHeader production. + ExitImportHeader(c *ImportHeaderContext) + + // ExitImportAlias is called when exiting the importAlias production. + ExitImportAlias(c *ImportAliasContext) + + // ExitTopLevelObject is called when exiting the topLevelObject production. + ExitTopLevelObject(c *TopLevelObjectContext) + + // ExitTypeAlias is called when exiting the typeAlias production. + ExitTypeAlias(c *TypeAliasContext) + + // ExitDeclaration is called when exiting the declaration production. + ExitDeclaration(c *DeclarationContext) + + // ExitClassDeclaration is called when exiting the classDeclaration production. + ExitClassDeclaration(c *ClassDeclarationContext) + + // ExitPrimaryConstructor is called when exiting the primaryConstructor production. + ExitPrimaryConstructor(c *PrimaryConstructorContext) + + // ExitClassBody is called when exiting the classBody production. + ExitClassBody(c *ClassBodyContext) + + // ExitClassParameters is called when exiting the classParameters production. + ExitClassParameters(c *ClassParametersContext) + + // ExitClassParameter is called when exiting the classParameter production. + ExitClassParameter(c *ClassParameterContext) + + // ExitDelegationSpecifiers is called when exiting the delegationSpecifiers production. + ExitDelegationSpecifiers(c *DelegationSpecifiersContext) + + // ExitDelegationSpecifier is called when exiting the delegationSpecifier production. + ExitDelegationSpecifier(c *DelegationSpecifierContext) + + // ExitConstructorInvocation is called when exiting the constructorInvocation production. + ExitConstructorInvocation(c *ConstructorInvocationContext) + + // ExitAnnotatedDelegationSpecifier is called when exiting the annotatedDelegationSpecifier production. + ExitAnnotatedDelegationSpecifier(c *AnnotatedDelegationSpecifierContext) + + // ExitExplicitDelegation is called when exiting the explicitDelegation production. + ExitExplicitDelegation(c *ExplicitDelegationContext) + + // ExitTypeParameters is called when exiting the typeParameters production. + ExitTypeParameters(c *TypeParametersContext) + + // ExitTypeParameter is called when exiting the typeParameter production. + ExitTypeParameter(c *TypeParameterContext) + + // ExitTypeConstraints is called when exiting the typeConstraints production. + ExitTypeConstraints(c *TypeConstraintsContext) + + // ExitTypeConstraint is called when exiting the typeConstraint production. + ExitTypeConstraint(c *TypeConstraintContext) + + // ExitClassMemberDeclarations is called when exiting the classMemberDeclarations production. + ExitClassMemberDeclarations(c *ClassMemberDeclarationsContext) + + // ExitClassMemberDeclaration is called when exiting the classMemberDeclaration production. + ExitClassMemberDeclaration(c *ClassMemberDeclarationContext) + + // ExitAnonymousInitializer is called when exiting the anonymousInitializer production. + ExitAnonymousInitializer(c *AnonymousInitializerContext) + + // ExitCompanionObject is called when exiting the companionObject production. + ExitCompanionObject(c *CompanionObjectContext) + + // ExitFunctionValueParameters is called when exiting the functionValueParameters production. + ExitFunctionValueParameters(c *FunctionValueParametersContext) + + // ExitFunctionValueParameter is called when exiting the functionValueParameter production. + ExitFunctionValueParameter(c *FunctionValueParameterContext) + + // ExitFunctionDeclaration is called when exiting the functionDeclaration production. + ExitFunctionDeclaration(c *FunctionDeclarationContext) + + // ExitFunctionBody is called when exiting the functionBody production. + ExitFunctionBody(c *FunctionBodyContext) + + // ExitVariableDeclaration is called when exiting the variableDeclaration production. + ExitVariableDeclaration(c *VariableDeclarationContext) + + // ExitMultiVariableDeclaration is called when exiting the multiVariableDeclaration production. + ExitMultiVariableDeclaration(c *MultiVariableDeclarationContext) + + // ExitPropertyDeclaration is called when exiting the propertyDeclaration production. + ExitPropertyDeclaration(c *PropertyDeclarationContext) + + // ExitPropertyDelegate is called when exiting the propertyDelegate production. + ExitPropertyDelegate(c *PropertyDelegateContext) + + // ExitGetter is called when exiting the getter production. + ExitGetter(c *GetterContext) + + // ExitSetter is called when exiting the setter production. + ExitSetter(c *SetterContext) + + // ExitParametersWithOptionalType is called when exiting the parametersWithOptionalType production. + ExitParametersWithOptionalType(c *ParametersWithOptionalTypeContext) + + // ExitFunctionValueParameterWithOptionalType is called when exiting the functionValueParameterWithOptionalType production. + ExitFunctionValueParameterWithOptionalType(c *FunctionValueParameterWithOptionalTypeContext) + + // ExitParameterWithOptionalType is called when exiting the parameterWithOptionalType production. + ExitParameterWithOptionalType(c *ParameterWithOptionalTypeContext) + + // ExitParameter is called when exiting the parameter production. + ExitParameter(c *ParameterContext) + + // ExitObjectDeclaration is called when exiting the objectDeclaration production. + ExitObjectDeclaration(c *ObjectDeclarationContext) + + // ExitSecondaryConstructor is called when exiting the secondaryConstructor production. + ExitSecondaryConstructor(c *SecondaryConstructorContext) + + // ExitConstructorDelegationCall is called when exiting the constructorDelegationCall production. + ExitConstructorDelegationCall(c *ConstructorDelegationCallContext) + + // ExitEnumClassBody is called when exiting the enumClassBody production. + ExitEnumClassBody(c *EnumClassBodyContext) + + // ExitEnumEntries is called when exiting the enumEntries production. + ExitEnumEntries(c *EnumEntriesContext) + + // ExitEnumEntry is called when exiting the enumEntry production. + ExitEnumEntry(c *EnumEntryContext) + + // ExitType is called when exiting the type production. + ExitType(c *TypeContext) + + // ExitTypeReference is called when exiting the typeReference production. + ExitTypeReference(c *TypeReferenceContext) + + // ExitNullableType is called when exiting the nullableType production. + ExitNullableType(c *NullableTypeContext) + + // ExitQuest is called when exiting the quest production. + ExitQuest(c *QuestContext) + + // ExitUserType is called when exiting the userType production. + ExitUserType(c *UserTypeContext) + + // ExitSimpleUserType is called when exiting the simpleUserType production. + ExitSimpleUserType(c *SimpleUserTypeContext) + + // ExitTypeProjection is called when exiting the typeProjection production. + ExitTypeProjection(c *TypeProjectionContext) + + // ExitTypeProjectionModifiers is called when exiting the typeProjectionModifiers production. + ExitTypeProjectionModifiers(c *TypeProjectionModifiersContext) + + // ExitTypeProjectionModifier is called when exiting the typeProjectionModifier production. + ExitTypeProjectionModifier(c *TypeProjectionModifierContext) + + // ExitFunctionType is called when exiting the functionType production. + ExitFunctionType(c *FunctionTypeContext) + + // ExitFunctionTypeParameters is called when exiting the functionTypeParameters production. + ExitFunctionTypeParameters(c *FunctionTypeParametersContext) + + // ExitParenthesizedType is called when exiting the parenthesizedType production. + ExitParenthesizedType(c *ParenthesizedTypeContext) + + // ExitReceiverType is called when exiting the receiverType production. + ExitReceiverType(c *ReceiverTypeContext) + + // ExitParenthesizedUserType is called when exiting the parenthesizedUserType production. + ExitParenthesizedUserType(c *ParenthesizedUserTypeContext) + + // ExitDefinitelyNonNullableType is called when exiting the definitelyNonNullableType production. + ExitDefinitelyNonNullableType(c *DefinitelyNonNullableTypeContext) + + // ExitStatements is called when exiting the statements production. + ExitStatements(c *StatementsContext) + + // ExitStatement is called when exiting the statement production. + ExitStatement(c *StatementContext) + + // ExitLabel is called when exiting the label production. + ExitLabel(c *LabelContext) + + // ExitControlStructureBody is called when exiting the controlStructureBody production. + ExitControlStructureBody(c *ControlStructureBodyContext) + + // ExitBlock is called when exiting the block production. + ExitBlock(c *BlockContext) + + // ExitLoopStatement is called when exiting the loopStatement production. + ExitLoopStatement(c *LoopStatementContext) + + // ExitForStatement is called when exiting the forStatement production. + ExitForStatement(c *ForStatementContext) + + // ExitWhileStatement is called when exiting the whileStatement production. + ExitWhileStatement(c *WhileStatementContext) + + // ExitDoWhileStatement is called when exiting the doWhileStatement production. + ExitDoWhileStatement(c *DoWhileStatementContext) + + // ExitAssignment is called when exiting the assignment production. + ExitAssignment(c *AssignmentContext) + + // ExitSemi is called when exiting the semi production. + ExitSemi(c *SemiContext) + + // ExitSemis is called when exiting the semis production. + ExitSemis(c *SemisContext) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitDisjunction is called when exiting the disjunction production. + ExitDisjunction(c *DisjunctionContext) + + // ExitConjunction is called when exiting the conjunction production. + ExitConjunction(c *ConjunctionContext) + + // ExitEquality is called when exiting the equality production. + ExitEquality(c *EqualityContext) + + // ExitComparison is called when exiting the comparison production. + ExitComparison(c *ComparisonContext) + + // ExitGenericCallLikeComparison is called when exiting the genericCallLikeComparison production. + ExitGenericCallLikeComparison(c *GenericCallLikeComparisonContext) + + // ExitInfixOperation is called when exiting the infixOperation production. + ExitInfixOperation(c *InfixOperationContext) + + // ExitElvisExpression is called when exiting the elvisExpression production. + ExitElvisExpression(c *ElvisExpressionContext) + + // ExitElvis is called when exiting the elvis production. + ExitElvis(c *ElvisContext) + + // ExitInfixFunctionCall is called when exiting the infixFunctionCall production. + ExitInfixFunctionCall(c *InfixFunctionCallContext) + + // ExitRangeExpression is called when exiting the rangeExpression production. + ExitRangeExpression(c *RangeExpressionContext) + + // ExitAdditiveExpression is called when exiting the additiveExpression production. + ExitAdditiveExpression(c *AdditiveExpressionContext) + + // ExitMultiplicativeExpression is called when exiting the multiplicativeExpression production. + ExitMultiplicativeExpression(c *MultiplicativeExpressionContext) + + // ExitAsExpression is called when exiting the asExpression production. + ExitAsExpression(c *AsExpressionContext) + + // ExitPrefixUnaryExpression is called when exiting the prefixUnaryExpression production. + ExitPrefixUnaryExpression(c *PrefixUnaryExpressionContext) + + // ExitUnaryPrefix is called when exiting the unaryPrefix production. + ExitUnaryPrefix(c *UnaryPrefixContext) + + // ExitPostfixUnaryExpression is called when exiting the postfixUnaryExpression production. + ExitPostfixUnaryExpression(c *PostfixUnaryExpressionContext) + + // ExitPostfixUnarySuffix is called when exiting the postfixUnarySuffix production. + ExitPostfixUnarySuffix(c *PostfixUnarySuffixContext) + + // ExitDirectlyAssignableExpression is called when exiting the directlyAssignableExpression production. + ExitDirectlyAssignableExpression(c *DirectlyAssignableExpressionContext) + + // ExitParenthesizedDirectlyAssignableExpression is called when exiting the parenthesizedDirectlyAssignableExpression production. + ExitParenthesizedDirectlyAssignableExpression(c *ParenthesizedDirectlyAssignableExpressionContext) + + // ExitAssignableExpression is called when exiting the assignableExpression production. + ExitAssignableExpression(c *AssignableExpressionContext) + + // ExitParenthesizedAssignableExpression is called when exiting the parenthesizedAssignableExpression production. + ExitParenthesizedAssignableExpression(c *ParenthesizedAssignableExpressionContext) + + // ExitAssignableSuffix is called when exiting the assignableSuffix production. + ExitAssignableSuffix(c *AssignableSuffixContext) + + // ExitIndexingSuffix is called when exiting the indexingSuffix production. + ExitIndexingSuffix(c *IndexingSuffixContext) + + // ExitNavigationSuffix is called when exiting the navigationSuffix production. + ExitNavigationSuffix(c *NavigationSuffixContext) + + // ExitCallSuffix is called when exiting the callSuffix production. + ExitCallSuffix(c *CallSuffixContext) + + // ExitAnnotatedLambda is called when exiting the annotatedLambda production. + ExitAnnotatedLambda(c *AnnotatedLambdaContext) + + // ExitTypeArguments is called when exiting the typeArguments production. + ExitTypeArguments(c *TypeArgumentsContext) + + // ExitValueArguments is called when exiting the valueArguments production. + ExitValueArguments(c *ValueArgumentsContext) + + // ExitValueArgument is called when exiting the valueArgument production. + ExitValueArgument(c *ValueArgumentContext) + + // ExitPrimaryExpression is called when exiting the primaryExpression production. + ExitPrimaryExpression(c *PrimaryExpressionContext) + + // ExitParenthesizedExpression is called when exiting the parenthesizedExpression production. + ExitParenthesizedExpression(c *ParenthesizedExpressionContext) + + // ExitCollectionLiteral is called when exiting the collectionLiteral production. + ExitCollectionLiteral(c *CollectionLiteralContext) + + // ExitLiteralConstant is called when exiting the literalConstant production. + ExitLiteralConstant(c *LiteralConstantContext) + + // ExitStringLiteral is called when exiting the stringLiteral production. + ExitStringLiteral(c *StringLiteralContext) + + // ExitLineStringLiteral is called when exiting the lineStringLiteral production. + ExitLineStringLiteral(c *LineStringLiteralContext) + + // ExitMultiLineStringLiteral is called when exiting the multiLineStringLiteral production. + ExitMultiLineStringLiteral(c *MultiLineStringLiteralContext) + + // ExitLineStringContent is called when exiting the lineStringContent production. + ExitLineStringContent(c *LineStringContentContext) + + // ExitLineStringExpression is called when exiting the lineStringExpression production. + ExitLineStringExpression(c *LineStringExpressionContext) + + // ExitMultiLineStringContent is called when exiting the multiLineStringContent production. + ExitMultiLineStringContent(c *MultiLineStringContentContext) + + // ExitMultiLineStringExpression is called when exiting the multiLineStringExpression production. + ExitMultiLineStringExpression(c *MultiLineStringExpressionContext) + + // ExitLambdaLiteral is called when exiting the lambdaLiteral production. + ExitLambdaLiteral(c *LambdaLiteralContext) + + // ExitLambdaParameters is called when exiting the lambdaParameters production. + ExitLambdaParameters(c *LambdaParametersContext) + + // ExitLambdaParameter is called when exiting the lambdaParameter production. + ExitLambdaParameter(c *LambdaParameterContext) + + // ExitAnonymousFunction is called when exiting the anonymousFunction production. + ExitAnonymousFunction(c *AnonymousFunctionContext) + + // ExitFunctionLiteral is called when exiting the functionLiteral production. + ExitFunctionLiteral(c *FunctionLiteralContext) + + // ExitObjectLiteral is called when exiting the objectLiteral production. + ExitObjectLiteral(c *ObjectLiteralContext) + + // ExitThisExpression is called when exiting the thisExpression production. + ExitThisExpression(c *ThisExpressionContext) + + // ExitSuperExpression is called when exiting the superExpression production. + ExitSuperExpression(c *SuperExpressionContext) + + // ExitIfExpression is called when exiting the ifExpression production. + ExitIfExpression(c *IfExpressionContext) + + // ExitWhenSubject is called when exiting the whenSubject production. + ExitWhenSubject(c *WhenSubjectContext) + + // ExitWhenExpression is called when exiting the whenExpression production. + ExitWhenExpression(c *WhenExpressionContext) + + // ExitWhenEntry is called when exiting the whenEntry production. + ExitWhenEntry(c *WhenEntryContext) + + // ExitWhenCondition is called when exiting the whenCondition production. + ExitWhenCondition(c *WhenConditionContext) + + // ExitRangeTest is called when exiting the rangeTest production. + ExitRangeTest(c *RangeTestContext) + + // ExitTypeTest is called when exiting the typeTest production. + ExitTypeTest(c *TypeTestContext) + + // ExitTryExpression is called when exiting the tryExpression production. + ExitTryExpression(c *TryExpressionContext) + + // ExitCatchBlock is called when exiting the catchBlock production. + ExitCatchBlock(c *CatchBlockContext) + + // ExitFinallyBlock is called when exiting the finallyBlock production. + ExitFinallyBlock(c *FinallyBlockContext) + + // ExitJumpExpression is called when exiting the jumpExpression production. + ExitJumpExpression(c *JumpExpressionContext) + + // ExitCallableReference is called when exiting the callableReference production. + ExitCallableReference(c *CallableReferenceContext) + + // ExitAssignmentAndOperator is called when exiting the assignmentAndOperator production. + ExitAssignmentAndOperator(c *AssignmentAndOperatorContext) + + // ExitEqualityOperator is called when exiting the equalityOperator production. + ExitEqualityOperator(c *EqualityOperatorContext) + + // ExitComparisonOperator is called when exiting the comparisonOperator production. + ExitComparisonOperator(c *ComparisonOperatorContext) + + // ExitInOperator is called when exiting the inOperator production. + ExitInOperator(c *InOperatorContext) + + // ExitIsOperator is called when exiting the isOperator production. + ExitIsOperator(c *IsOperatorContext) + + // ExitAdditiveOperator is called when exiting the additiveOperator production. + ExitAdditiveOperator(c *AdditiveOperatorContext) + + // ExitMultiplicativeOperator is called when exiting the multiplicativeOperator production. + ExitMultiplicativeOperator(c *MultiplicativeOperatorContext) + + // ExitAsOperator is called when exiting the asOperator production. + ExitAsOperator(c *AsOperatorContext) + + // ExitPrefixUnaryOperator is called when exiting the prefixUnaryOperator production. + ExitPrefixUnaryOperator(c *PrefixUnaryOperatorContext) + + // ExitPostfixUnaryOperator is called when exiting the postfixUnaryOperator production. + ExitPostfixUnaryOperator(c *PostfixUnaryOperatorContext) + + // ExitExcl is called when exiting the excl production. + ExitExcl(c *ExclContext) + + // ExitMemberAccessOperator is called when exiting the memberAccessOperator production. + ExitMemberAccessOperator(c *MemberAccessOperatorContext) + + // ExitSafeNav is called when exiting the safeNav production. + ExitSafeNav(c *SafeNavContext) + + // ExitModifiers is called when exiting the modifiers production. + ExitModifiers(c *ModifiersContext) + + // ExitParameterModifiers is called when exiting the parameterModifiers production. + ExitParameterModifiers(c *ParameterModifiersContext) + + // ExitModifier is called when exiting the modifier production. + ExitModifier(c *ModifierContext) + + // ExitTypeModifiers is called when exiting the typeModifiers production. + ExitTypeModifiers(c *TypeModifiersContext) + + // ExitTypeModifier is called when exiting the typeModifier production. + ExitTypeModifier(c *TypeModifierContext) + + // ExitClassModifier is called when exiting the classModifier production. + ExitClassModifier(c *ClassModifierContext) + + // ExitMemberModifier is called when exiting the memberModifier production. + ExitMemberModifier(c *MemberModifierContext) + + // ExitVisibilityModifier is called when exiting the visibilityModifier production. + ExitVisibilityModifier(c *VisibilityModifierContext) + + // ExitVarianceModifier is called when exiting the varianceModifier production. + ExitVarianceModifier(c *VarianceModifierContext) + + // ExitTypeParameterModifiers is called when exiting the typeParameterModifiers production. + ExitTypeParameterModifiers(c *TypeParameterModifiersContext) + + // ExitTypeParameterModifier is called when exiting the typeParameterModifier production. + ExitTypeParameterModifier(c *TypeParameterModifierContext) + + // ExitFunctionModifier is called when exiting the functionModifier production. + ExitFunctionModifier(c *FunctionModifierContext) + + // ExitPropertyModifier is called when exiting the propertyModifier production. + ExitPropertyModifier(c *PropertyModifierContext) + + // ExitInheritanceModifier is called when exiting the inheritanceModifier production. + ExitInheritanceModifier(c *InheritanceModifierContext) + + // ExitParameterModifier is called when exiting the parameterModifier production. + ExitParameterModifier(c *ParameterModifierContext) + + // ExitReificationModifier is called when exiting the reificationModifier production. + ExitReificationModifier(c *ReificationModifierContext) + + // ExitPlatformModifier is called when exiting the platformModifier production. + ExitPlatformModifier(c *PlatformModifierContext) + + // ExitAnnotation is called when exiting the annotation production. + ExitAnnotation(c *AnnotationContext) + + // ExitSingleAnnotation is called when exiting the singleAnnotation production. + ExitSingleAnnotation(c *SingleAnnotationContext) + + // ExitMultiAnnotation is called when exiting the multiAnnotation production. + ExitMultiAnnotation(c *MultiAnnotationContext) + + // ExitAnnotationUseSiteTarget is called when exiting the annotationUseSiteTarget production. + ExitAnnotationUseSiteTarget(c *AnnotationUseSiteTargetContext) + + // ExitUnescapedAnnotation is called when exiting the unescapedAnnotation production. + ExitUnescapedAnnotation(c *UnescapedAnnotationContext) + + // ExitSimpleIdentifier is called when exiting the simpleIdentifier production. + ExitSimpleIdentifier(c *SimpleIdentifierContext) + + // ExitIdentifier is called when exiting the identifier production. + ExitIdentifier(c *IdentifierContext) +} diff --git a/lib/archer/model.go b/lib/archer/model.go new file mode 100644 index 0000000..05fa071 --- /dev/null +++ b/lib/archer/model.go @@ -0,0 +1,323 @@ +package archer + +import ( + "fmt" + "sort" + "strings" + + "github.com/Faire/archer/lib/archer/utils" +) + +type Project struct { + Root string + Name string + NameParts []string + Type ProjectType + + RootDir string + Dir string + ProjectFile string + + dependencies map[string]*Dependency + size map[string]Size + config map[string]string + + dataDir string +} + +func NewProject(root, name string) *Project { + return &Project{ + Root: root, + Name: name, + dependencies: map[string]*Dependency{}, + size: map[string]Size{}, + config: map[string]string{}, + } +} + +func (p *Project) String() string { + return fmt.Sprintf("%v[%v]", p.Name, p.Type) +} + +func (p *Project) AddDependency(d *Project) *Dependency { + result := &Dependency{ + Source: p, + Target: d, + config: map[string]string{}, + } + + p.dependencies[d.Name] = result + + return result +} + +func (p *Project) AddSize(name string, size Size) { + p.size[name] = size +} + +func (p *Project) GetSize() Size { + result := Size{ + Other: map[string]int{}, + } + + for _, v := range p.size { + result.Add(v) + } + + return result +} + +func (p *Project) GetSizeOf(name string) Size { + result, ok := p.size[name] + + if !ok { + result = Size{ + Other: map[string]int{}, + } + } + + return result +} + +func (p *Project) FullName() string { + return p.Root + ":" + p.Name +} + +func (p *Project) SimpleName() string { + return p.LevelSimpleName(0) +} + +func (p *Project) LevelSimpleName(level int) string { + if len(p.NameParts) == 0 { + return p.Name + } + + parts := p.NameParts + + if level > 0 { + parts = utils.Take(parts, level) + } + + parts = simplifyPrefixes(parts) + + result := strings.Join(parts, ":") + + if len(p.Name) <= len(result) { + result = p.Name + } + + return result +} + +func simplifyPrefixes(parts []string) []string { + for len(parts) > 1 && strings.HasPrefix(parts[1], parts[0]) { + parts = parts[1:] + } + return parts +} + +func (p *Project) IsIgnored() bool { + return utils.IsTrue(p.GetConfig("ignore")) +} + +func (p *Project) IsCode() bool { + return p.Type == CodeType +} + +func (p *Project) IsExternalDependency() bool { + return p.Type == ExternalDependencyType +} + +func (p *Project) ListDependencies(filter FilterType) []*Dependency { + result := make([]*Dependency, 0, len(p.dependencies)) + + for _, v := range p.dependencies { + if filter == FilterExcludeExternal && v.Target.IsExternalDependency() { + continue + } + + result = append(result, v) + } + + sortDependencies(result) + + return result +} + +func sortDependencies(result []*Dependency) { + sort.Slice(result, func(i, j int) bool { + pi := result[i].Source + pj := result[j].Source + + if pi.Name == pj.Name { + pi = result[i].Target + pj = result[j].Target + } + + if pi.IsCode() && pj.IsExternalDependency() { + return true + } + + if pi.IsExternalDependency() && pj.IsCode() { + return false + } + + return strings.TrimLeft(pi.Name, ":") < strings.TrimLeft(pj.Name, ":") + }) +} + +func (p *Project) SetConfig(config string, value string) bool { + if p.GetConfig(config) == value { + return false + } + + if value == "" { + delete(p.config, config) + } else { + p.config[config] = value + } + + return true +} + +func (p *Project) GetConfig(config string) string { + v, _ := p.config[config] + return v +} + +type Dependency struct { + Source *Project + Target *Project + config map[string]string +} + +func (d *Dependency) String() string { + return fmt.Sprintf("%v -> %v", d.Source, d.Target) +} + +func (d *Dependency) SetConfig(config string, value string) bool { + if d.GetConfig(config) == value { + return false + } + + if value == "" { + delete(d.config, config) + } else { + d.config[config] = value + } + + return true +} + +func (d *Dependency) GetConfig(config string) string { + v, _ := d.config[config] + return v +} + +type Projects struct { + all map[string]*Project +} + +func NewProjects() *Projects { + return &Projects{ + all: map[string]*Project{}, + } +} + +func (ps *Projects) GetOrNil(name string) *Project { + if len(name) == 0 { + panic("empty name not supported") + } + + result, ok := ps.all[name] + if !ok { + return nil + } + + return result +} + +func (ps *Projects) Get(root, name string) *Project { + if len(root) == 0 { + panic("empty root not supported") + } + if len(name) == 0 { + panic("empty name not supported") + } + + key := root + "\n" + name + result, ok := ps.all[key] + + if !ok { + result = NewProject(root, name) + ps.all[key] = result + } + + return result +} + +func (ps *Projects) ListProjects(filter FilterType) []*Project { + result := make([]*Project, 0, len(ps.all)) + + for _, v := range ps.all { + if filter == FilterExcludeExternal && v.IsExternalDependency() { + continue + } + + result = append(result, v) + } + + sortProjects(result) + + return result +} + +func sortProjects(result []*Project) { + sort.Slice(result, func(i, j int) bool { + pi := result[i] + pj := result[j] + + if pi.IsCode() && pj.IsExternalDependency() { + return true + } + + if pi.IsExternalDependency() && pj.IsCode() { + return false + } + + return strings.TrimLeft(pi.Name, ":") < strings.TrimLeft(pj.Name, ":") + }) +} + +type Size struct { + Lines int + Files int + Bytes int + Other map[string]int +} + +func (l *Size) Add(other Size) { + l.Lines += other.Lines + l.Files += other.Files + l.Bytes += other.Bytes + + for k, v := range other.Other { + o, _ := l.Other[k] + l.Other[k] = o + v + } +} + +type FilterType int + +const ( + FilterAll FilterType = iota + FilterExcludeExternal +) + +type ProjectType int + +const ( + ExternalDependencyType ProjectType = iota + CodeType + DatabaseType +) diff --git a/lib/archer/mysql/mysql_importer.go b/lib/archer/mysql/mysql_importer.go new file mode 100644 index 0000000..26f50a9 --- /dev/null +++ b/lib/archer/mysql/mysql_importer.go @@ -0,0 +1,174 @@ +package mysql + +import ( + "database/sql" + "fmt" + "time" + + "github.com/dustin/go-humanize" + _ "github.com/go-sql-driver/mysql" + "github.com/pkg/errors" + + "github.com/Faire/archer/lib/archer" + "github.com/Faire/archer/lib/archer/common" +) + +type mysqlImporter struct { + connectionString string + storage *archer.Storage +} + +func NewImporter(connectionString string) archer.Importer { + return &mysqlImporter{ + connectionString: connectionString, + } +} + +func (m *mysqlImporter) Import(projs *archer.Projects, storage *archer.Storage) error { + m.storage = storage + + db, err := sql.Open("mysql", m.connectionString) + if err != nil { + return errors.Wrapf(err, "error connecting to MySQL using %v", m.connectionString) + } + + defer db.Close() + + db.SetConnMaxLifetime(time.Minute) + db.SetMaxOpenConns(1) + db.SetMaxIdleConns(1) + + err = m.importTables(db, projs) + if err != nil { + return err + } + + err = m.importFKs(db, projs) + if err != nil { + return err + } + + return nil +} + +func (m *mysqlImporter) importTables(db *sql.DB, projs *archer.Projects) error { + results, err := db.Query(` + select TABLE_SCHEMA schema_name, + TABLE_NAME table_name, + TABLE_ROWS rows, + DATA_LENGTH data_size, + INDEX_LENGTH index_size + from information_schema.TABLES + where TABLE_TYPE = 'BASE TABLE' + and TABLE_SCHEMA <> 'information_schema' + `) + if err != nil { + return errors.Wrap(err, "error querying database tables") + } + + type tableInfo struct { + schemaName string + tableName string + rows int + dataSize int + indexSize int + } + + var changedProjs []*archer.Project + + for results.Next() { + var table tableInfo + + err = results.Scan(&table.schemaName, &table.tableName, &table.rows, &table.dataSize, &table.indexSize) + if err != nil { + return errors.Wrap(err, "error querying database tables") + } + + fmt.Printf("Importing table %v.%v (%v data, %v indexes)\n", table.schemaName, table.tableName, + humanize.Bytes(uint64(table.dataSize)), humanize.Bytes(uint64(table.indexSize))) + + proj := projs.Get(table.schemaName, table.tableName) + proj.Type = archer.DatabaseType + + proj.AddSize("table", archer.Size{ + Lines: table.rows, + Bytes: table.dataSize + table.indexSize, + Other: map[string]int{ + "data": table.dataSize, + "indexes": table.indexSize, + }, + }) + + changedProjs = append(changedProjs, proj) + } + + common.CreateTableNameParts(changedProjs) + + for _, proj := range changedProjs { + err = m.storage.WriteBasicInfoFile(proj) + if err != nil { + return err + } + + err = m.storage.WriteSizeFile(proj) + if err != nil { + return err + } + } + + return nil +} + +func (m *mysqlImporter) importFKs(db *sql.DB, projs *archer.Projects) error { + results, err := db.Query(` + select CONSTRAINT_SCHEMA schema_name, + TABLE_NAME, + REFERENCED_TABLE_NAME + from information_schema.REFERENTIAL_CONSTRAINTS + `) + if err != nil { + return errors.Wrap(err, "error querying database FKs") + } + + type fkInfo struct { + schemaName string + tableName string + referencedTableName string + } + + type rootAndName struct { + root string + name string + } + toSave := map[rootAndName]bool{} + + for results.Next() { + var fk fkInfo + + err = results.Scan(&fk.schemaName, &fk.tableName, &fk.referencedTableName) + if err != nil { + return errors.Wrap(err, "error querying database FKs") + } + + fmt.Printf("Importing dependency %v.%v => %v.%v\n", + fk.schemaName, fk.tableName, fk.schemaName, fk.referencedTableName) + + proj := projs.Get(fk.schemaName, fk.tableName) + + dep := projs.Get(fk.schemaName, fk.referencedTableName) + proj.AddDependency(dep) + + toSave[rootAndName{fk.schemaName, fk.tableName}] = true + } + + for k := range toSave { + proj := projs.Get(k.root, k.name) + + err = m.storage.WriteDepsFile(proj) + if err != nil { + return err + } + } + + return nil +} diff --git a/lib/archer/storage.go b/lib/archer/storage.go new file mode 100644 index 0000000..eb242d4 --- /dev/null +++ b/lib/archer/storage.go @@ -0,0 +1,302 @@ +package archer + +import ( + "io/fs" + "os" + "path/filepath" + "strings" +) + +const ( + projNamesJson = "projNames.json" + depsJson = "deps.json" + sizeJson = "size.json" + basicInfoJson = "proj.json" + configJson = "config.json" +) + +type Storage struct { + root string +} + +func NewStorage(root string) (*Storage, error) { + return &Storage{ + root: root, + }, nil +} + +func (s *Storage) LoadProjects(result *Projects) error { + return filepath.WalkDir(s.root, func(path string, d fs.DirEntry, err error) error { + switch d.Name() { + case basicInfoJson: + err = s.ReadBasicInfoFile(result, path) + if err != nil { + return err + } + + case configJson: + err = s.ReadConfigFile(result, path) + if err != nil { + return err + } + + case depsJson: + err = s.ReadDepsFile(result, path) + if err != nil { + return err + } + + case sizeJson: + err := s.ReadSizeFile(result, path) + if err != nil { + return err + } + } + + return nil + }) +} + +func (s *Storage) GetProjNamesFileName(root string) (string, error) { + return filepath.Abs(filepath.Join( + s.root, + strings.ReplaceAll(root, ":", "_"), + projNamesJson, + )) +} + +func (s *Storage) WriteProjNamesFile(fileName string, projRoot string, projNames []string) error { + err := os.MkdirAll(filepath.Dir(fileName), 0o700) + if err != nil { + return err + } + + content, err := ProjNamesToJson(projRoot, projNames) + if err != nil { + return err + } + + err = os.WriteFile(fileName, []byte(content), 0o600) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) ReadProjNamesFile(fileName string) ([]string, error) { + contents, err := os.ReadFile(fileName) + if err != nil { + return nil, err + } + + _, result, err := ProjNamesFromJson(string(contents)) + if err != nil { + return nil, err + } + + return result, nil +} + +func (s *Storage) computeDataDir(proj *Project) error { + dir, err := filepath.Abs(filepath.Join( + s.root, + proj.Root, + strings.TrimLeft(strings.ReplaceAll(proj.Name, ":", string(os.PathSeparator)), string(os.PathSeparator)), + )) + if err != nil { + return err + } + + proj.dataDir = dir + + return nil +} + +func (s *Storage) GetDepsFileName(proj *Project) (string, error) { + err := s.computeDataDir(proj) + if err != nil { + return "", err + } + + return filepath.Join(proj.dataDir, depsJson), nil +} + +func (s *Storage) WriteDepsFile(proj *Project) error { + fileName, err := s.GetDepsFileName(proj) + if err != nil { + return err + } + + err = os.MkdirAll(filepath.Dir(fileName), 0o700) + if err != nil { + return err + } + + jc, err := DepsToJson(proj) + if err != nil { + return err + } + + err = os.WriteFile(fileName, []byte(jc), 0o600) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) ReadDepsFile(result *Projects, fileName string) error { + contents, err := os.ReadFile(fileName) + if err != nil { + return err + } + + err = DepsFromJson(result, string(contents)) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) GetSizeFileName(proj *Project) (string, error) { + err := s.computeDataDir(proj) + if err != nil { + return "", err + } + + return filepath.Join(proj.dataDir, sizeJson), nil +} + +func (s *Storage) WriteSizeFile(proj *Project) error { + fileName, err := s.GetSizeFileName(proj) + if err != nil { + return err + } + + err = os.MkdirAll(filepath.Dir(fileName), 0o700) + if err != nil { + return err + } + + jc, err := SizeToJson(proj) + if err != nil { + return err + } + + err = os.WriteFile(fileName, []byte(jc), 0o600) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) ReadSizeFile(result *Projects, fileName string) error { + contents, err := os.ReadFile(fileName) + if err != nil { + return err + } + + err = SizeFromJson(result, string(contents)) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) GetBasicInfoFileName(proj *Project) (string, error) { + err := s.computeDataDir(proj) + if err != nil { + return "", err + } + + return filepath.Join(proj.dataDir, basicInfoJson), nil +} + +func (s *Storage) WriteBasicInfoFile(proj *Project) error { + fileName, err := s.GetBasicInfoFileName(proj) + if err != nil { + return err + } + + err = os.MkdirAll(filepath.Dir(fileName), 0o700) + if err != nil { + return err + } + + jc, err := BasicInfoToJson(proj) + if err != nil { + return err + } + + err = os.WriteFile(fileName, []byte(jc), 0o600) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) ReadBasicInfoFile(result *Projects, fileName string) error { + contents, err := os.ReadFile(fileName) + if err != nil { + return err + } + + err = BasicInfoFromJson(result, string(contents), fileName) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) GetConfigFileName(proj *Project) (string, error) { + err := s.computeDataDir(proj) + if err != nil { + return "", err + } + + return filepath.Join(proj.dataDir, configJson), nil +} + +func (s *Storage) WriteConfigFile(proj *Project) error { + fileName, err := s.GetConfigFileName(proj) + if err != nil { + return err + } + + err = os.MkdirAll(filepath.Dir(fileName), 0o700) + if err != nil { + return err + } + + jc, err := ConfigToJson(proj) + if err != nil { + return err + } + + err = os.WriteFile(fileName, []byte(jc), 0o600) + if err != nil { + return err + } + + return nil +} + +func (s *Storage) ReadConfigFile(result *Projects, fileName string) error { + contents, err := os.ReadFile(fileName) + if err != nil { + return err + } + + err = ConfigFromJson(result, string(contents)) + if err != nil { + return err + } + + return nil +} diff --git a/lib/archer/utils/processgroup.go b/lib/archer/utils/processgroup.go new file mode 100644 index 0000000..cf15975 --- /dev/null +++ b/lib/archer/utils/processgroup.go @@ -0,0 +1,92 @@ +package utils + +import ( + "runtime" + "sync" +) + +type ProcessGroup[I, O any] struct { + proc func(I) (O, error) + abort chan struct{} + wg sync.WaitGroup + + Input chan I + Output chan O + Err chan error +} + +func NewProcessGroup[I, O any](proc func(I) (O, error)) ProcessGroup[I, O] { + routines := Max(Min(runtime.GOMAXPROCS(-1), runtime.NumCPU())-2, 1) + + group := ProcessGroup[I, O]{ + proc: proc, + abort: make(chan struct{}), + + Input: make(chan I), + Output: make(chan O), + Err: make(chan error), + } + + for i := 0; i < routines; i++ { + group.wg.Add(1) + go group.runProcessor() + } + + go func() { + group.wg.Wait() + close(group.Output) + close(group.Err) + }() + + return group +} + +func (g *ProcessGroup[I, O]) runProcessor() { + defer g.wg.Done() + + for { + select { + case <-g.abort: + return + + case input, ok := <-g.Input: + if !ok { + return + } + + output, err := g.proc(input) + if err != nil { + g.Abort(err) + return + } + + g.Output <- output + } + } +} + +func (g *ProcessGroup[I, O]) FinishedInput() { + close(g.Input) +} + +func (g *ProcessGroup[I, O]) Abort(err error) { + g.Err <- err + close(g.abort) +} + +func (g *ProcessGroup[I, O]) Aborted() bool { + select { + case <-g.abort: + return true + default: + return false + } +} + +func (g *ProcessGroup[I, O]) Close() { + close(g.abort) + close(g.Input) + close(g.Output) + close(g.Err) + g.wg.Wait() +} diff --git a/lib/archer/utils/utils.go b/lib/archer/utils/utils.go new file mode 100644 index 0000000..f57d785 --- /dev/null +++ b/lib/archer/utils/utils.go @@ -0,0 +1,118 @@ +package utils + +import ( + "os" + "path/filepath" + "strings" + + "golang.org/x/exp/constraints" +) + +func Take[T any](l []T, i int) []T { + if i < 0 { + i = Max(0, len(l)-1+i) + } else { + i = Min(i, len(l)) + } + return l[:i] +} + +func First[T any](l []T) T { + return l[0] +} + +func Last[T any](l []T) T { + return l[len(l)-1] +} + +func RemoveLast[T any](l []T) []T { + return l[:len(l)-1] +} + +func Min[T constraints.Ordered](a T, bs ...T) T { + result := a + for _, b := range bs { + if result > b { + result = b + } + } + return result +} + +func Max[T constraints.Ordered](a T, bs ...T) T { + result := a + for _, b := range bs { + if result < b { + result = b + } + } + return result +} + +func IIf[T any](test bool, ifTrue, ifFalse T) T { + if test { + return ifTrue + } else { + return ifFalse + } +} + +func MapContains[K comparable, V any](m map[K]V, k K) bool { + _, ok := m[k] + return ok +} + +func MapMapContains[K1, K2 comparable, V any](m1 map[K1]map[K2]V, k1 K1, k2 K2) bool { + m2, ok := m1[k1] + if !ok { + return false + } + + _, ok = m2[k2] + + return ok +} + +func mapGetOrUpdate[K comparable, V any](m map[K]V, k K, update func() V) V { + v, ok := m[k] + + if !ok { + v = update() + m[k] = v + } + + return v +} + +func IsTrue(v string) bool { + v = strings.ToLower(v) + return v != "false" && v != "f" && v != "no" && v != "n" && v != "" +} + +func in[T comparable](el T, options ...T) bool { + for _, o := range options { + if el == o { + return true + } + } + + return false +} + +func PathAbs(path string) (string, error) { + if strings.HasPrefix(filepath.ToSlash(path), "~/") { + home, err := os.UserHomeDir() + if err != nil { + return "", err + } + + path = filepath.Join(home, path[2:]) + } + + path, err := filepath.Abs(path) + if err != nil { + return "", err + } + + return path, nil +} diff --git a/lib/archer/workspace.go b/lib/archer/workspace.go new file mode 100644 index 0000000..d6313c8 --- /dev/null +++ b/lib/archer/workspace.go @@ -0,0 +1,79 @@ +package archer + +import ( + "fmt" + "os" + + "github.com/Faire/archer/lib/archer/utils" +) + +type Workspace struct { + storage *Storage +} + +func NewWorkspace(root string) (*Workspace, error) { + if root == "" { + if _, err := os.Stat("./.archer"); err == nil { + root = "./.archer" + } else { + root = "~/.archer" + } + } + + root, err := utils.PathAbs(root) + if err != nil { + return nil, err + } + + if _, err := os.Stat(root); err != nil { + fmt.Printf("Creating workspace at %v\n", root) + err := os.MkdirAll(root, 0o700) + if err != nil { + return nil, err + } + } + + storage, err := NewStorage(root) + if err != nil { + return nil, err + } + + return &Workspace{ + storage: storage, + }, nil +} + +func (w *Workspace) LoadProjects() (*Projects, error) { + result := NewProjects() + + err := w.storage.LoadProjects(result) + if err != nil { + return nil, err + } + + return result, nil +} + +func (w *Workspace) Import(importer Importer) error { + projs := NewProjects() + + err := w.storage.LoadProjects(projs) + if err != nil { + return err + } + + return importer.Import(projs, w.storage) +} + +func (w *Workspace) SetConfigParameter(proj *Project, config string, value string) (bool, error) { + changed := proj.SetConfig(config, value) + + if changed { + err := w.storage.WriteConfigFile(proj) + if err != nil { + return false, err + } + } + + return changed, nil +}